srm-ifce-1.18.0/0000755001662700052000000000000012217066060012300 5ustar adevresscgsrm-ifce-1.18.0/packaging/0000755001662700052000000000000012217066060014224 5ustar adevresscgsrm-ifce-1.18.0/packaging/rpm/0000755001662700052000000000000012217066060015022 5ustar adevresscgsrm-ifce-1.18.0/packaging/rpm/specs/0000755001662700052000000000000012217066060016137 5ustar adevresscgsrm-ifce-1.18.0/packaging/rpm/specs/srm-ifce.spec0000644001662700052000000001140612217066060020522 0ustar adevresscg# unversionned doc dir F20 change https://fedoraproject.org/wiki/Changes/UnversionedDocdirs %{!?_pkgdocdir: %global _pkgdocdir %{_docdir}/%{name}-%{version}} Name: srm-ifce Version: 1.18.0 Release: 1%{?dist} Summary: SRM client side library Group: Applications/Internet License: ASL 2.0 URL: https://svnweb.cern.ch/trac/lcgutil # svn export http://svn.cern.ch/guest/lcgutil/srm-ifce/trunk srm-ifce Source0: http://grid-deployment.web.cern.ch/grid-deployment/dms/lcgutil/tar/%{name}/%{name}-%{version}.tar.gz BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX) BuildRequires: cmake BuildRequires: CGSI-gSOAP-devel BuildRequires: glib2-devel BuildRequires: globus-ftp-client-devel BuildRequires: globus-gss-assist-devel %description srm-ifce is a client side implementation of the SRMv2 specification for GFAL1/2 and FTS. SRM means Storage Resource Manager Interface, it is a specification of a SOAP interface providing a generic way to manage distributed storage systems. %package devel Summary: SRM client side headers and development files Group: Development/Libraries Requires: %{name}%{?_isa} = %{version}-%{release} Requires: glib2-devel Requires: pkgconfig %description devel Development libraries, pkgconfig files and header files for the srm-ifce. %prep %setup -q %build %cmake -D DOC_INSTALL_DIR=%{_pkgdocdir} . make %{?_smp_mflags} %install rm -rf $RPM_BUILD_ROOT make %{?_smp_mflags} DESTDIR=$RPM_BUILD_ROOT install %clean rm -rf $RPM_BUILD_ROOT %post -p /sbin/ldconfig %postun -p /sbin/ldconfig %files %defattr (-,root,root) %{_bindir}/gfal_srm_ifce_version %{_libdir}/libgfal_srm_ifce.so.* %{_pkgdocdir}/LICENSE %{_pkgdocdir}/VERSION %{_pkgdocdir}/README %files devel %defattr (-,root,root) %{_libdir}/pkgconfig/* %{_libdir}/libgfal_srm_ifce.so %{_includedir}/gfal_srm_ifce.h %{_includedir}/gfal_srm_ifce_types.h %{_pkgdocdir}/RELEASE-NOTES %changelog * Fri Sep 20 2013 Adrien Devresse - 1.18.0-1 - Release srm-ifce 1.18.0 * Tue Aug 19 2013 Alejandro Alvarez - 1.17.0-0 - Release srm-ifce 1.17.0 * Tue Jul 02 2013 Adrien Devresse - 1.16.0-0 - Release srm-ifce 1.16.0, first post-EMI release * Mon Jun 10 2013 Michail Salichos - 1.15.3-3 - fixing memory leaks * Fri Apr 26 2013 Michail Salichos - 1.15.3-2 - added srmmv implementation * Wed Mar 20 2013 adevress at cern.ch - 1.15.2-1 - EMI lcgutil 1.15.0 release * Thu Mar 14 2013 Michail Salichos - 1.15.2-0 - avoid double initialization when session reuse is enabled * Fri Feb 22 2013 Adrien Devresse - 1.15.1-0 - fix an estimatedWaitTime problem with the backoff logic - introduce srm session reuse * Tue Jan 08 2013 Adrien Devresse - 1.14.0-1 - correct two timeout bug LCGUTIL-78 and LCGUTIL-82 * Thu Nov 29 2012 Adrien Devresse - 1.14.0-0 - correct misleading namespace in PrepareToGetRequestStatus - correct a timeout issue related to exponential backoff system in put/get - improve reliability of the exponential backoff wait system - big big code cleaning - re-factory of the context system with backward compatibility - fix the srm timeout issue - fix the srm put done issue for long transfer * Fri Jul 20 2012 Adrien Devresse - 1.13.0-0 - Synchronise with EMI 2 Update 13 - introduction of operation timeout - buffer overflow and memory corruption corrections - minor warning corrections * Wed Apr 18 2012 Zsolt Molnar - 1.12.3-1 - Integrating to EPEL, adapting to changes in external components * Tue Feb 14 2012 Adrien Devresse - 1.12.2-10 - correct smash stack related to gsoap * Thu Feb 09 2012 Adrien Devresse - 1.12.2-9 - correct gsoap issue for f18 * Thu Feb 09 2012 Adrien Devresse - 1.12.2-8 - Recompile with gsoap 2.8 compatibility * Thu Feb 02 2012 Adrien Devresse - 1.12.2-7 - remove macro of pkgconfig dependency causing bug on i686 pkgs * Mon Jan 30 2012 Adrien Devresse - 1.12.2-6 - Fix a stack smash problem relative to gsoap internal struct * Sun Jan 15 2012 Adrien Devresse - 1.12.1-5 - add pkg-config files - add dist macro - correct buildroot path * Wed Jan 11 2012 Adrien Devresse - 1.12.1-4 - Add a fixed source tree for packaging - Correct a problem of include with gcc 4.6 * Thu Jan 05 2012 Adrien Devresse - 1.12.1-3 - Second Revision for EPEL/fedora conformance * Fri Dec 16 2011 Adrien Devresse - 1.12.1-2 - First Revision for EPEL/fedora conformance * Mon Nov 28 2011 Adrien Devresse - 1.12.1-1 - Initial build srm-ifce-1.18.0/packaging/bin/0000755001662700052000000000000012217066060014774 5ustar adevresscgsrm-ifce-1.18.0/packaging/bin/packager_rpm.sh0000755001662700052000000000534512217066060017775 0ustar adevresscg#!/bin/bash ## help tool for generic packaging # @author: Devresse Adrien ## vars BASE_TMP=/tmp FINAL_DIR="RPMS/" TARBALL_FILTER="--exclude='.git' --exclude='.svn' --exclude='RPMS' --exclude='*.rpm'" FOO="HELLO" set -e create_tmp_dir() { export TMP_DIR="$BASE_TMP/$RANDOM$RANDOM$RANDOM_$$" mkdir -p $TMP_DIR } get_attrs_spec(){ export SPEC_CONTENT="$(rpm -E "`cat $1 | head -n 50`")" export PKG_VERSION="$( echo "$SPEC_CONTENT" | grep "Version:" | sed 's@Version:\(.*\)@\1@g' | sed -e 's/^[ \t]*//')" export PKG_RELEASE="$( echo "$SPEC_CONTENT" | grep "Version:" | sed 's@Release:\(.*\)@\1@g' | sed -e 's/^[ \t]*//')" export PKG_NAME="$(echo "$SPEC_CONTENT" | grep "Name:" | sed 's@Name:\(.*\)@\1@g' | sed -e 's/^[ \t]*//')" export SPEC_CONTENT="$(echo "$SPEC_CONTENT" | sed "s/%{name}/$PKG_NAME/g" | sed "s/%{version}/$PKG_VERSION/g" | sed "s/%{Release}/$PKG_RELEASE/g")" export PKG_SOURCE="$( echo "$SPEC_CONTENT" | grep "Source0:" | sed 's@Source0:\(.*\)@\1@g' )" export PKG_SOURCE="$( echo $PKG_SOURCE | awk -F/ '{print $NF'})" export SRC_NAME="$PKG_SOURCE" echo "res : $SRC_NAME $PKG_VERSION $PKG_NAME $PKG_SOURCE" } # src_dir, tarbal_filepath create_tarball(){ create_tmp_dir SRC_FOLDER="/$TMP_DIR/$PKG_NAME-$PKG_VERSION" mkdir -p "$SRC_FOLDER" echo "copy files..." cp -r $1/* $SRC_FOLDER/ CURRENT_DIR=$PWD cd $TMP_DIR echo "copy files..." eval "tar -cvzf $2 $TARBALL_FILTER $PKG_NAME-$PKG_VERSION" echo "tarball result : $2 $TARBALL_FILTER " cd $CURRENT_DIR rm -rf $TMP_DIR } # specfiles_dir create_rpmbuild_env(){ create_tmp_dir export RPM_BUILD_DIR="$TMP_DIR" mkdir -p $RPM_BUILD_DIR/RPMS $RPM_BUILD_DIR/SOURCES $RPM_BUILD_DIR/BUILD $RPM_BUILD_DIR/SRPMS $RPM_BUILD_DIR/SPECS $RPM_BUILD_DIR/tmp cp $1/* $RPM_BUILD_DIR/SPECS/ } # specfiles_dir delete_rpmbuild_env(){ rm -rf $RPM_BUILD_DIR/ } # specfile rpm_build_src_package(){ echo "Begin the rpmbuild source call for spec file $1 ...." local OLD_DIR=$PWD local MACRO_TOPDIR="s \"_topdir $RPM_BUILD_DIR\"" cd $RPM_BUILD_DIR ls $PWD/SOURCES/ rpmbuild -bs --nodeps --define "_topdir $RPM_BUILD_DIR" SPECS/$1 cd $OLD_DIR echo "End the rpmbuild source call...." } ## main if [[ "$1" == "" || "$2" == "" ]]; then echo "Usage $0 [spec_dir] [src_dir] " exit -1 fi create_rpmbuild_env $1 mkdir -p SRPMS # list spec file for i in $1/*.spec do echo " create RPMS for spec file : $i" get_attrs_spec $i echo "Source : $SRC_NAME" echo "Version : $PKG_VERSION" echo "Name: $PKG_NAME" echo "create source tarball..." create_tarball $2 "$RPM_BUILD_DIR/SOURCES/$SRC_NAME" echo "TARBALL: $RPM_BUILD_DIR/SOURCES/$SRC_NAME" rpm_build_src_package `basename $i` done mkdir -p $FINAL_DIR cp $RPM_BUILD_DIR/SRPMS/* $FINAL_DIR ## clean everything delete_rpmbuild_env srm-ifce-1.18.0/project/0000755001662700052000000000000012217066060013746 5ustar adevresscgsrm-ifce-1.18.0/CMakeLists.txt0000644001662700052000000000220212217066060015034 0ustar adevresscg## cmake build script for srm-ifce project (srm-ifce) cmake_minimum_required (VERSION 2.6) message("cmake source dir : ${CMAKE_SOURCE_DIR}") # build type set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "type of build") set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules/") #enable testing INCLUDE(CTest) # load module include(DefineInstallationPaths REQUIRED) include(MacroCopyFile REQUIRED) include(ReleaseDebugAutoFlags REQUIRED) include(CMakeGeneratePkgConfig REQUIRED) find_package(PkgConfig REQUIRED) find_package(gSOAP REQUIRED) find_package(CGSI_GSOAP REQUIRED) #define opts set(UNIT_TESTS FALSE CACHE STRING "enable or disable unit test compilation") #define PROJECT vars set(PROJECT_NAME "srm-ifce") set(OUTPUT_NAME "gfal_srm_ifce") set(VERSION_MAJOR 1) set(VERSION_MINOR 18) set(VERSION_PATCH 0) set(VERSION_STRING ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}) # libs checks pkg_check_modules(GSOAP_PKG REQUIRED gsoap) pkg_check_modules(GLIB2_PKG REQUIRED glib-2.0) #install doc license install(FILES "LICENSE" "RELEASE-NOTES" "VERSION" "README" DESTINATION ${DOC_INSTALL_DIR}) add_subdirectory (src) srm-ifce-1.18.0/src/0000755001662700052000000000000012217066060013067 5ustar adevresscgsrm-ifce-1.18.0/src/srmv2_discovery_functions.h0000644001662700052000000000166112217066060020474 0ustar adevresscg#pragma once #ifndef _SRMV2_DISCOVERY_FUNCTIONS_ #define _SRMV2_DISCOVERY_FUNCTIONS_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_ping(struct srm_context *context,struct srm_ping_output *output); #endif srm-ifce-1.18.0/src/srmv2_discovery_functions.c0000644001662700052000000000302212217066060020460 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include "srm_soap.h" #include "srm_util.h" #include "srm_dependencies.h" int srmv2_ping(struct srm_context *context,struct srm_ping_output *output) { const char srmfunc[] = "AbortRequest"; struct srm2__srmPingRequest req; struct srm2__srmPingResponse_ rep; struct soap* soap = srm_soap_init_context_new(context); int result; memset (&req, 0, sizeof(req)); result = call_function.call_srm2__srmPing (soap, context->srm_endpoint, srmfunc, &req, &rep); if (result != 0) { // Soap call failure errno = srm_soap_call_err(context,soap,srmfunc); }else { if (rep.srmPingResponse == NULL || copy_string(&output->versioninfo,rep.srmPingResponse->versionInfo)) { errno = EINVAL; srm_soap_free(soap); return (-1); } } srm_soap_free(soap); return result; } srm-ifce-1.18.0/src/srmv2_permission_functions.h0000644001662700052000000000235712217066060020660 0ustar adevresscg#pragma once #ifndef _SRMV2_PERMISSION_FUNCTIONS_ #define _SRMV2_PERMISSION_FUNCTIONS_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_set_permission(struct srm_context *context, struct srm_setpermission_input *input); int srmv2_get_permission(struct srm_context *context, struct srm_getpermission_input *input, struct srm_getpermission_output *output); int srmv2_check_permission(struct srm_context *context, struct srm_checkpermission_input *input, struct srmv2_filestatus **statuses); #endif srm-ifce-1.18.0/src/typemap-srmv2.dat0000755001662700052000000000012412217066060016307 0ustar adevresscgsrm2 = http://srm.lbl.gov/StorageResourceManager xsd__dateTime = | char * | char * srm-ifce-1.18.0/src/srmv2_space_management_functions.h0000644001662700052000000000342012217066060021747 0ustar adevresscg#pragma once #ifndef _SRMV2_SPACE_MANAGEMENT_FUNCTIONS_ #define _SRMV2_SPACE_MANAGEMENT_FUNCTIONS_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_getspacemd (struct srm_context *context, struct srm_getspacemd_input *input,struct srm_spacemd **spaces); // returns space tokens associated to the space description int srmv2_getspacetokens (struct srm_context *context, struct srm_getspacetokens_input *input, struct srm_getspacetokens_output *output); // returns best space token char* srmv2_getbestspacetoken (struct srm_context *context, struct srm_getbestspacetokens_input *input); // returns space tokens associated to the space description int srmv2_reservespace(struct srm_context *context, struct srm_reservespace_input *input, struct srm_reservespace_output *output); int srmv2_releasespace(struct srm_context *context, char *spacetoken); int srmv2_purgefromspace(struct srm_context *context, struct srm_purgefromspace_input *input, struct srm_purgefromspace_output *output); #endif srm-ifce-1.18.0/src/CMakeLists.txt0000644001662700052000000001056112217066060015632 0ustar adevresscg## src cmake build script for srm-ifce FILE(GLOB src_libs1 "*function*.c") FILE(GLOB src_libs2 "*dependencies*.c") FILE(GLOB src_libs3 "*wrapper*.c") FILE(GLOB src_libs4 "*util*.c") FILE(GLOB src_program "gfal_srm_ifce_version.c") FILE(GLOB src_unit_tests "*unittest*.c") FILE(GLOB src_system_tests "*systemtest*.c") LIST(APPEND src_libs ${src_libs1} ${src_libs2} ${src_libs3} ${src_libs4}) ## gsoap generation # srmv1 set(srmv1_typemap "typemap-srmv1.dat") set(srmv1_wsdl "srm.v1.1.wsdl") set(srm1_header_files "srm.v1.1.h") set(srm1_source_files "srmC.c") set(srm1_dir "srmv1") file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${srm1_dir}) add_custom_command( OUTPUT ${srm1_header_files} DEPENDS ${srmv1_typemap} ${srmv1_wsdl} COMMAND ${GSOAP_WSDL2H} ${GSOAP_276_COMPAT_FLAGS} -c -e -y -z -t ${CMAKE_CURRENT_SOURCE_DIR}/${srmv1_typemap} ${CMAKE_CURRENT_SOURCE_DIR}/${srmv1_wsdl} -o ${srm1_header_files}) add_custom_command( OUTPUT ${srm1_source_files} ${srm1_map_files} DEPENDS ${srm1_header_files} COMMAND ${GSOAP_SOAPCPP2} -c -d ${CMAKE_CURRENT_BINARY_DIR}/${srm1_dir} -p srm ${srm1_header_files} ) #srmv2 set(srm2_dir "${CMAKE_CURRENT_BINARY_DIR}/srmv2") set(srmv2_typemap "typemap-srmv2.dat") set(srmv2_wsdl "srm.v2.2.wsdl") set(srm_map_files "${srm2_dir}/srmSoapBinding.nsmap") set(srm2_header_files "${srm2_dir}/srm.v2.2.h") set(srm2_source_file1 "${srm2_dir}/srmv2C.c") set(srm2_source_file2 "${srm2_dir}/srmv2Client.c") file(MAKE_DIRECTORY ${srm2_dir}) add_custom_command( OUTPUT ${srm2_header_files} DEPENDS ${srmv2_typemap} ${srmv2_wsdl} COMMAND ${GSOAP_WSDL2H} ${GSOAP_276_COMPAT_FLAGS} -c -e -y -t ${CMAKE_CURRENT_SOURCE_DIR}/${srmv2_typemap} ${CMAKE_CURRENT_SOURCE_DIR}/${srmv2_wsdl} -o ${srm2_header_files}) add_custom_command( OUTPUT ${srm2_source_file1} ${srm2_source_file2} DEPENDS ${srm2_header_files} COMMAND ${GSOAP_SOAPCPP2} -c -d ${srm2_dir} -p srmv2 ${srm2_header_files} ) # transform typemap set(srm_map_files_c "srmSoapBinding.c") add_custom_command(OUTPUT ${srm_map_files_c} DEPENDS ${srm2_source_file1} COMMAND cp ${srm_map_files} ${CMAKE_CURRENT_BINARY_DIR}/${srm_map_files_c} ) set_source_files_properties(${srm_map_files_c} ${srm2_source_file1} ${srm2_source_file2} PROPERTIES GENERATED TRUE) add_definitions(-D_LARGEFILE64_SOURCE -DVERSION="${VERSION_STRING}" -DCMAKE_BUILD -D_GNU_SOURCE -DGFAL_SECURE -Wall ${GSOAP_PKG_CFLAGS} ${GSOAP_PKG_CFLAGS_OTHER}) include_directories(${srm2_dir} ${CGSI_GSOAP_INCLUDE_DIRS} ${GLIB2_PKG_INCLUDE_DIRS}) link_directories( ${CGSI_GSOAP_LIBRARY_DIRS} ) ## main libs add_library(srm-ifce SHARED ${src_libs} ${srm2_source_file1} ${srm2_source_file2} ${CMAKE_CURRENT_BINARY_DIR}/${srm_map_files_c}) target_link_libraries(srm-ifce ${GSOAP_PKG_LIBRARIES} ${CGSI_GSOAP_LIBRARIES} ${GLIB2_PKG_LIBRARIES} rt) set_target_properties(srm-ifce PROPERTIES VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH} SOVERSION ${VERSION_MAJOR} CLEAN_DIRECT_OUTPUT 1 OUTPUT_NAME ${OUTPUT_NAME} ) # add a package config file add_PkgConfigFile_for_Library(srm-ifce.pc srm-ifce) ## version control add_executable(gfal_srm_ifce_version ${src_program}) target_link_libraries(gfal_srm_ifce_version ) IF (UNIT_TESTS) link_directories (${PROJECT_BINARY_DIR}/ ${PROJECT_BINARY_DIR}/src) ## unit tests add_executable(gfal_srm_ifce_unittest ${src_unit_tests} ) target_link_libraries(gfal_srm_ifce_unittest ${OUTPUT_NAME} check srm-ifce ${GSOAP_PKG_LIBRARIES} ${CGSI_GSOAP_LIBRARIES} ${GLIB2_PKG_LIBRARIES}) add_executable(gfal_srm_ifce_systemtest ${src_system_tests} ) target_link_libraries(gfal_srm_ifce_systemtest ${OUTPUT_NAME} check srm-ifce ${GSOAP_PKG_LIBRARIES} ${CGSI_GSOAP_LIBRARIES} ${GLIB2_PKG_LIBRARIES}) add_test(base_unit_test ${CMAKE_BINARY_DIR}/gfal_srm_ifce_unittest) #add_test(base_system_test ${CMAKE_BINARY_DIR}/gfal_srm_ifce_systemtest) ENDIF (UNIT_TESTS) install(TARGETS srm-ifce RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX} LIBRARY DESTINATION ${LIB_INSTALL_DIR} ) install(TARGETS gfal_srm_ifce_version RUNTIME DESTINATION ${BIN_INSTALL_DIR}) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/srm-ifce.pc" DESTINATION ${PKGCONFIG_FILES_DIR}) install(FILES "gfal_srm_ifce_types.h" "gfal_srm_ifce.h" DESTINATION ${INCLUDE_INSTALL_DIR}) srm-ifce-1.18.0/src/srmv2_permission_functions.c0000644001662700052000000001672312217066060020655 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srmv2_permission_functions.h" #include "srm_soap.h" int srmv2_set_permission(struct srm_context *context, struct srm_setpermission_input *input) { int result = 0,i; const char srmfunc[] = "SetPermission"; struct srm2__srmSetPermissionRequest req; struct srm2__srmSetPermissionResponse_ rep; enum srm2__TPermissionMode otherPermission; enum srm2__TPermissionMode ownerPermission; struct soap* soap = srm_soap_init_context_new(context); memset (&req, 0, sizeof(req)); if ((req.arrayOfGroupPermissions = soap_malloc (soap, sizeof(struct srm2__ArrayOfTGroupPermission))) == NULL || (req.arrayOfGroupPermissions->groupPermissionArray = soap_malloc (soap, input->group_permissions_count* sizeof(struct srm2__TGroupPermission *))) == NULL || (req.arrayOfUserPermissions = soap_malloc (soap, sizeof(struct srm2__ArrayOfTUserPermission))) == NULL || (req.arrayOfUserPermissions->userPermissionArray = soap_malloc (soap,input->user_permissions_count* sizeof(struct srm2__TUserPermission*))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfGroupPermissions->__sizegroupPermissionArray = input->group_permissions_count; req.arrayOfUserPermissions->__sizeuserPermissionArray = input->user_permissions_count; for (i = 0; i < input->group_permissions_count; i++) { if ((req.arrayOfGroupPermissions->groupPermissionArray[i] = soap_malloc (soap, sizeof(struct srm2__TGroupPermission))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } memset (req.arrayOfGroupPermissions->groupPermissionArray[i], 0, sizeof(struct srm2__TGroupPermission)); req.arrayOfGroupPermissions->groupPermissionArray[i]->groupID = (char *)input->group_permissions[i].name_id; req.arrayOfGroupPermissions->groupPermissionArray[i]->mode = input->group_permissions[i].mode; } for (i = 0; i < input->user_permissions_count; i++) { if ((req.arrayOfUserPermissions->userPermissionArray[i] = soap_malloc (soap, sizeof(struct srm2__TUserPermission))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } memset (req.arrayOfUserPermissions->userPermissionArray[i], 0, sizeof(struct srm2__TUserPermission)); req.arrayOfUserPermissions->userPermissionArray[i]->userID = (char *)input->user_permissions[i].name_id; req.arrayOfUserPermissions->userPermissionArray[i]->mode = input->user_permissions[i].mode; } req.SURL = input->surl; req.storageSystemInfo = NULL; req.authorizationID = NULL; otherPermission = (enum srm2__TPermissionMode)input->other_permission; ownerPermission = (enum srm2__TPermissionMode)input->owner_permission; req.otherPermission = &otherPermission; req.ownerPermission = &ownerPermission; req.permissionType = input->permission_type; result = call_function.call_srm2__srmSetPermission (soap, context->srm_endpoint, srmfunc, &req, &rep); if (result != 0|| rep.srmSetPermissionResponse== NULL || rep.srmSetPermissionResponse->returnStatus == NULL) { // Soap call failure errno = srm_soap_call_err(context, soap,srmfunc); result = -1; }else { // check response if (rep.srmSetPermissionResponse->returnStatus->statusCode != SRM_USCORESUCCESS) { errno = statuscode2errno(rep.srmSetPermissionResponse->returnStatus->statusCode); srm_soap_free(soap); return (-1); } } srm_soap_free(soap); return result; } int srmv2_get_permission(struct srm_context *context, struct srm_getpermission_input *input, struct srm_getpermission_output *output) { const char srmfunc[] = "GetPermission"; struct srm2__srmGetPermissionRequest req; struct srm2__srmGetPermissionResponse_ rep; struct srm2__ArrayOfTPermissionReturn *repperm; struct soap* soap = srm_soap_init_context_new(context); int result = 0; memset (&req, 0, sizeof(req)); memset(output,0,sizeof(*output)); if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **)input->surls; req.authorizationID = NULL; req.storageSystemInfo = NULL; result = call_function.call_srm2__srmGetPermission (soap, context->srm_endpoint, srmfunc, &req, &rep); // check response if (result != 0 || rep.srmGetPermissionResponse == NULL || copy_returnstatus(&output->retstatus,rep.srmGetPermissionResponse->returnStatus)) { // Soap call failure errno = srm_soap_call_err(context,soap,srmfunc); result = -1; }else { repperm = rep.srmGetPermissionResponse->arrayOfPermissionReturns; if (output->retstatus->statusCode == SRM_USCORESUCCESS || output->retstatus->statusCode == SRM_USCOREPARTIAL_USCORESUCCESS) { result = copy_filepermissions(output->retstatus, &output->permissions, repperm); }else { errno = srm_call_err(context,output->retstatus,srmfunc); result = -1; } } srm_soap_free(soap); return result; } int srmv2_check_permission(struct srm_context *context, struct srm_checkpermission_input *input, struct srmv2_filestatus **statuses) { int ret; struct srm2__srmCheckPermissionResponse_ rep; struct srm2__ArrayOfTSURLPermissionReturn *repfs; struct srm2__srmCheckPermissionRequest req; struct srm2__TReturnStatus *reqstatp; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "CheckPermission"; memset (&req, 0, sizeof(req)); /* NOTE: only one SURL in the array */ if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **) input->surls; if (call_function.call_srm2__srmCheckPermission (soap, context->srm_endpoint, srmfunc, &req, &rep) != 0) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if (rep.srmCheckPermissionResponse == NULL || (reqstatp = rep.srmCheckPermissionResponse->returnStatus) == NULL) { srm_errmsg (context, "[SRM][%s][] %s: ",srmfunc, context->srm_endpoint); srm_soap_free(soap); errno = ECOMM; return (-1); } repfs = rep.srmCheckPermissionResponse->arrayOfPermissions; if (!repfs || repfs->__sizesurlPermissionArray < 1 || !repfs->surlPermissionArray) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } ret = copy_permissionfilestatuses(reqstatp, statuses, repfs, srmfunc, input->amode); srm_soap_free(soap); return (ret); } srm-ifce-1.18.0/src/srmv2_directory_functions.h0000644001662700052000000000455712217066060020500 0ustar adevresscg#pragma once #ifndef _SRMV2_DIRECTORY_FUNCTIONS_H_ #define _SRMV2_DIRECTORY_FUNCTIONS_H_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Adrien Devresse, CERN */ #include "srm_ifce_internal.h" // Utility functions int srmv2_check_srm_root(const char* surl); int srmv2_rm(struct srm_context *context,struct srm_rm_input *input,struct srm_rm_output *output); int srmv2_rmdir(struct srm_context *context,struct srm_rmdir_input *input,struct srm_rmdir_output *output); int srmv2_mkdir(struct srm_context *context,struct srm_mkdir_input *input); int srmv2_ls_async_internal(struct srm_context *context, struct srm_ls_input *input,struct srm_ls_output *output,struct srm_internal_context *internal_context); int srmv2_status_of_ls_request_async_internal(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output, struct srm_internal_context *internal_context); int srmv2_rm(struct srm_context *context,struct srm_rm_input *input,struct srm_rm_output *output); //srmv2_rmdir (const char *surl, const char *srm_endpoint, int recursive, //struct srmv2_filestatus **statuses, char *errbuf, int errbufsz, int timeout) int srmv2_rmdir(struct srm_context *context,struct srm_rmdir_input *input,struct srm_rmdir_output *output); /* tries to create all directories in 'dest_file' */ int srmv2_mkdir(struct srm_context *context,struct srm_mkdir_input *input); int srmv2_extend_file_lifetime(struct srm_context *context, struct srm_extendfilelifetime_input *input, struct srm_extendfilelifetime_output *output); int srmv2_check_srm_root(const char* surl); int srmv2_mv(struct srm_context *context, struct srm_mv_input *input); #endif srm-ifce-1.18.0/src/gfal_srm_ifce_version.c0000644001662700052000000000176112217066060017565 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include "gfal_srm_ifce.h" /* the version should be set by a "define" at the makefile level */ static const char version[] = VERSION; int main(int argc, char **argv) { printf ("gfal-srm-ifce--%s\n", version); exit (0); } srm-ifce-1.18.0/src/gfal_srm_ifce_internal.h0000644001662700052000000000163712217066060017723 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Zsolt Molnar, CERN */ #ifndef _GFAL_SRM_IFCE_INTERNAL_H_ #define _GFAL_SRM_IFCE_INTERNAL_H_ #include #include "gfal_srm_ifce.h" #include "srm_ifce_internal.h" #endif /* _GFAL_SRM_IFCE_INTERNAL_H_ */ srm-ifce-1.18.0/src/srm_util.c0000644001662700052000000012326412217066060015101 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include #include #include #include #include #include "srmv2Stub.h" #include "srm_soap.h" #include "srm_util.h" #include "gfal_srm_ifce_internal.h" #ifdef CMAKE_BUILD #define namespaces_srmv2 namespaces #endif const char *err_msg_begin = "SE"; const char *srmv2_errmsg[] = { "SRM_SUCCESS", "SRM_FAILURE", "SRM_AUTHENTICATION_FAILURE", "SRM_AUTHORIZATION_FAILURE", "SRM_INVALID_REQUEST", "SRM_INVALID_PATH", "SRM_FILE_LIFETIME_EXPIRED", "SRM_SPACE_LIFETIME_EXPIRED", "SRM_EXCEED_ALLOCATION", "SRM_NO_USER_SPACE", "SRM_NO_FREE_SPACE", "SRM_DUPLICATION_ERROR", "SRM_NON_EMPTY_DIRECTORY", "SRM_TOO_MANY_RESULTS", "SRM_INTERNAL_ERROR", "SRM_FATAL_INTERNAL_ERROR", "SRM_NOT_SUPPORTED", "SRM_REQUEST_QUEUED", "SRM_REQUEST_INPROGRESS", "SRM_REQUEST_SUSPENDED", "SRM_ABORTED", "SRM_RELEASED", "SRM_FILE_PINNED", "SRM_FILE_IN_CACHE", "SRM_SPACE_AVAILABLE", "SRM_LOWER_SPACE_GRANTED", "SRM_DONE", "SRM_PARTIAL_SUCCESS", "SRM_REQUEST_TIMED_OUT", "SRM_LAST_COPY", "SRM_FILE_BUSY", "SRM_FILE_LOST", "SRM_FILE_UNAVAILABLE", "SRM_CUSTOM_STATUS" }; static int srm_timeout_connect = 60; static int srm_timeout_sendreceive = 3600; int srm_get_timeout_connect () { return (srm_timeout_connect); } void srm_set_timeout_connect (int value) { if (value >= 0) srm_timeout_connect = value; } int srm_get_timeout_sendreceive () { return (srm_timeout_sendreceive); } void srm_set_timeout_sendreceive (int value) { if (value >= 0) srm_timeout_sendreceive = value; } void back_off_logic_init(struct srm_context *context,struct srm_internal_context *internal_context) { GFAL_SRM_IFCE_ASSERT(context); GFAL_SRM_IFCE_ASSERT(internal_context); memset(internal_context,0, sizeof(struct srm_internal_context)); clock_gettime(CLOCK_MONOTONIC, &internal_context->end_time_spec); if (context->timeout > 0) { internal_context->relative_timeout = context->timeout; internal_context->end_time = (time(NULL) + internal_context->relative_timeout); internal_context->end_time_spec.tv_sec+= internal_context->relative_timeout; }else{ internal_context->relative_timeout = 180; internal_context->end_time = (time(NULL) + internal_context->relative_timeout); internal_context->end_time_spec.tv_sec+= internal_context->relative_timeout; } internal_context->estimated_wait_time = -1; internal_context->attempt = 1; if(context->ext){ timespec_add(&(internal_context->current_waittime_spec), &(context->ext->min_waittime), &(internal_context->current_waittime_spec)); } internal_context->random_seed = (unsigned int) time(NULL); } void set_estimated_wait_time(struct srm_internal_context *internal_context, int my_time) { // safety check on the serve value, if > relative_timeout -> fallback on eponential backoff logic internal_context->estimated_wait_time = (my_time > 0 && my_time < internal_context->relative_timeout)?my_time:-1; } void srm_soap_init(struct soap *soap) { #ifdef GFAL_SECURE int flags; #endif soap_init (soap); soap->namespaces = namespaces_srmv2; #ifdef GFAL_SECURE flags = CGSI_OPT_DISABLE_NAME_CHECK; soap_register_plugin_arg (soap, client_cgsi_plugin, &flags); #endif soap->send_timeout = srm_get_timeout_sendreceive (); soap->recv_timeout = srm_get_timeout_sendreceive (); soap->connect_timeout = srm_get_timeout_connect (); } struct soap * srm_soap_init_new() { return srm_soap_init_context_new(NULL); } struct soap * srm_soap_init_context_new(struct srm_context* c){ #ifdef GFAL_SECURE int flags; #endif struct soap *soap_handle = NULL; if (c && c->ext && c->ext->keep_alive) { soap_handle = soap_new2(SOAP_IO_KEEPALIVE, SOAP_IO_KEEPALIVE); soap_handle->bind_flags |= SO_REUSEADDR; soap_handle->accept_timeout = 0; soap_handle->tcp_keep_alive = 1; soap_handle->socket_flags = MSG_NOSIGNAL; } else { soap_handle = soap_new(); } soap_handle->namespaces = namespaces_srmv2; #ifdef GFAL_SECURE flags = CGSI_OPT_DISABLE_NAME_CHECK | CGSI_OPT_KEEP_ALIVE; soap_register_plugin_arg (soap_handle, client_cgsi_plugin, &flags); #endif if(c){ soap_handle->recv_timeout= c->timeout_ops; soap_handle->send_timeout = c->timeout_ops; soap_handle->connect_timeout = c->timeout_conn; }else{ soap_handle->send_timeout = srm_get_timeout_sendreceive (); soap_handle->recv_timeout = srm_get_timeout_sendreceive (); soap_handle->connect_timeout = srm_get_timeout_connect (); } return soap_handle; } void srm_soap_deinit(struct soap *soap) { soap_end (soap); soap_done (soap); } void srm_soap_free(struct soap *soap) { const int srm_ifce_errno = errno; soap_end (soap); soap_done (soap); soap_free(soap); // override errno with srm-ifce specific value // hack for globus openssl errno problems errno = srm_ifce_errno; } const char * statuscode2errmsg (unsigned int statuscode) { if(statuscode < (sizeof(srmv2_errmsg)/sizeof(char*))) return (srmv2_errmsg[statuscode]); return srmv2_errmsg[1]; } int statuscode2errno (int statuscode) { switch (statuscode) { case SRM_USCOREINVALID_USCOREPATH: return (ENOENT); case SRM_USCOREAUTHORIZATION_USCOREFAILURE: return (EACCES); case SRM_USCOREDUPLICATION_USCOREERROR: return (EEXIST); case SRM_USCORENO_USCOREFREE_USCORESPACE: return (ENOSPC); case SRM_USCOREINTERNAL_USCOREERROR: return (ECOMM); case SRM_USCORENOT_USCORESUPPORTED: return (EOPNOTSUPP); case SRM_USCORENON_USCOREEMPTY_USCOREDIRECTORY: return (ENOTEMPTY); case SRM_USCORESUCCESS: case SRM_USCOREFILE_USCOREPINNED: case SRM_USCORESPACE_USCOREAVAILABLE: return (0); default: return (EINVAL); } } int statuscode_and_msg_to_errno(int statuscode, const char** err_tab_msg){ int err_code = statuscode2errno(statuscode); if(err_code == EINVAL && err_tab_msg != NULL){ // search for string pattern char** err_tab = (char**) err_tab_msg; while(*err_tab != NULL){ // search for pattern EEXIST, LCGUTIL-203 bug if( strstr(*err_tab,"exists, overwite is not allowed") != NULL) err_code = EEXIST; ++err_tab; } } return err_code; } void srm_errmsg (struct srm_context *context, const char *format, ...) { va_list ap; char *actual_format; if ((context->errbuf == NULL && context->verbose == 0) || format == NULL || format[0] == 0) return; va_start (ap, format); (void)asprintf (&actual_format, "%s\n", format); if (actual_format == NULL){ va_end(ap); return; } if (context->errbuf == NULL) vfprintf (stderr, actual_format, ap); else vsnprintf (context->errbuf, context->errbufsz, actual_format, ap); free (actual_format); va_end(ap); } int srm_soap_call_err(struct srm_context *context,struct soap *soap,const char *srmfunc) { if (soap->fault != NULL && soap->fault->faultstring != NULL) { srm_errmsg (context, "[%s][%s][] %s: %s",err_msg_begin, srmfunc, context->srm_endpoint, soap->fault->faultstring); }else if (soap->error == SOAP_EOF) { srm_errmsg (context, "[%s][%s][] %s: Connection fails or timeout", err_msg_begin,srmfunc,context->srm_endpoint); }else { srm_errmsg (context, "[%s][%s][] %s: Unknown SOAP error (%d)", err_msg_begin,srmfunc,context->srm_endpoint, soap->error); } return ECOMM; } int srm_call_err(struct srm_context *context,struct srm2__TReturnStatus *retstatus, const char *srmfunc) { int result_errno; if (retstatus == NULL) { srm_errmsg (context, "[%s][%s][] %s: ",err_msg_begin, srmfunc,context->srm_endpoint); return ECOMM; } if (retstatus->statusCode != SRM_USCORESUCCESS && retstatus->statusCode != SRM_USCOREPARTIAL_USCORESUCCESS && retstatus->statusCode != SRM_USCOREDONE && retstatus->statusCode != SRM_USCORETOO_USCOREMANY_USCORERESULTS) { const char * tab_err_msg[] = { retstatus->explanation, NULL }; result_errno = statuscode_and_msg_to_errno(retstatus->statusCode, tab_err_msg); if (retstatus->explanation && retstatus->explanation[0]) { srm_errmsg (context, "[%s][%s][%s] %s: %s",err_msg_begin, srmfunc, statuscode2errmsg (retstatus->statusCode), context->srm_endpoint, retstatus->explanation); }else { srm_errmsg (context, "[%s][%s][%s] %s: ",err_msg_begin, srmfunc, statuscode2errmsg (retstatus->statusCode), context->srm_endpoint); } } else { srm_errmsg (context, "[%s][%s][%s] %s: ",err_msg_begin, srmfunc, statuscode2errmsg (retstatus->statusCode), context->srm_endpoint); result_errno = ECOMM; } return result_errno; } // return error status int srm_print_error_status(struct srm_context *context,struct srm2__TReturnStatus *status,const char *srmfunc) { if (status->explanation && status->explanation[0]) { srm_errmsg (context, "[%s][%s][%s] %s: %s",err_msg_begin, srmfunc, statuscode2errmsg (status->statusCode), context->srm_endpoint, status->explanation); }else { srm_errmsg (context, "[%s][%s][%s] %s: ",err_msg_begin, srmfunc, statuscode2errmsg (status->statusCode), context->srm_endpoint); } return statuscode2errno (status->statusCode); } int srm_print_error_status_additional(struct srm_context *context,struct srm2__TReturnStatus *status,const char *srmfunc,char *additional_info) { if (status->explanation && status->explanation[0]) { srm_errmsg (context, "[%s][%s][%s] %s: %s: %s",err_msg_begin, srmfunc, statuscode2errmsg (status->statusCode), context->srm_endpoint,additional_info, status->explanation); }else { srm_errmsg (context, "[%s][%s][%s] %s: %s: ",err_msg_begin, srmfunc, statuscode2errmsg (status->statusCode), context->srm_endpoint,additional_info); } return statuscode2errno (status->statusCode); } void srm_print_explanation(char **explanation,struct srm2__TReturnStatus *reqstatp,const char *srmfunc) { if (reqstatp->explanation != NULL && reqstatp->explanation[0]) (void)asprintf(explanation, "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg( reqstatp->statusCode), reqstatp->explanation); else (void)asprintf(explanation, "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg( reqstatp->statusCode)); } int wait_for_new_attempt_min_max_ng(srm_context_t context, struct srm_internal_context *internal_context){ int ret =-1; // default -> go timeout struct timespec sleep_time, current_time, end_sleep_time; clock_gettime(CLOCK_MONOTONIC, ¤t_time); timespec_add(&(internal_context->current_waittime_spec), &(current_time), &(end_sleep_time)); if( timespec_cmp(&end_sleep_time, &(internal_context->end_time_spec), <) ){ //printf(" I wil sleep %ld %ld", internal_context->current_waittime_spec.tv_sec, internal_context->current_waittime_spec.tv_nsec); while(timespec_cmp(&(current_time), &end_sleep_time, <)){ // go to sleep for the exact required time call_function.call_usleep(1); clock_gettime(CLOCK_MONOTONIC, ¤t_time); } ret =0; } // double the wait time if < max timespec_add(&(internal_context->current_waittime_spec),&(internal_context->current_waittime_spec), &(sleep_time)); if(timespec_cmp(&sleep_time, &(context->ext->max_waittime), <) ){ timespec_copy(&(internal_context->current_waittime_spec), &sleep_time); }else{ timespec_copy(&(internal_context->current_waittime_spec), &(context->ext->max_waittime)); } return ret; } // Returns -1 for timeout // Returns 0 for wait finished int wait_for_new_attempt(struct srm_internal_context *internal_context) // Or Timeout { const time_t last_chance_sec_before_end = 2; // 2 seconds before the end int random_limit; int random_wait; time_t wait_till_end=0; time_t after_sleep; after_sleep = time(NULL) ; if (internal_context->estimated_wait_time <= 0 && internal_context->estimated_wait_time < ( internal_context->end_time - time(NULL))) { // Exponential logic if (internal_context->attempt<=10) // Maximum 10 attempts { random_limit = (time_t) (1<<(internal_context->attempt)); random_wait = (rand_r(&(internal_context->random_seed)) % random_limit)+1; internal_context->attempt++; after_sleep += (time_t) random_wait; if (after_sleep >= internal_context->end_time) { wait_till_end = internal_context->end_time - time(NULL) - last_chance_sec_before_end; //try the last hope before the end if (wait_till_end>0) call_function.call_sleep(wait_till_end); else // deadline outdated, return -1; // simply return in timeout }else { call_function.call_sleep(random_wait); } }else { // Timeout, attempts exceeded return -1; } }else{ after_sleep += internal_context->estimated_wait_time ; if (after_sleep >= internal_context->end_time) { wait_till_end = internal_context->end_time - (time(NULL)+last_chance_sec_before_end); if (wait_till_end>0) { call_function.call_sleep(wait_till_end); }else { // Timeout return -1; } }else { call_function.call_sleep(internal_context->estimated_wait_time ); } } return 0; } int wait_switch_auto(srm_context_t context, struct srm_internal_context *internal_context){ if(context->ext == NULL) return wait_for_new_attempt(internal_context); switch(context->ext->polling_logic){ case SRM_POLLING_LOGIC_OLD: return wait_for_new_attempt(internal_context); case SRM_POLLING_LOGIC_MIN_MAX_EXP: default: return wait_for_new_attempt_min_max_ng(context, internal_context); } return -1; } // Return all statuses timeout, failure,internal error, queued srm_call_status back_off_logic(struct srm_context *context,const char *srmfunc, struct srm_internal_context *internal_context,struct srm2__TReturnStatus *retstatus) { if (retstatus == NULL) { srm_errmsg (context, "[%s][%s][] %s: ",err_msg_begin, srmfunc, context->srm_endpoint); errno = ECOMM; // No response status return srm_call_status_FAILURE; }else { switch (retstatus->statusCode ) { case SRM_USCOREINTERNAL_USCOREERROR: if (wait_switch_auto(context,internal_context) != 0) { srm_errmsg (context, "[%s][%s][ETIMEDOUT] %s: User timeout over", err_msg_begin,srmfunc, context->srm_endpoint); errno = ETIMEDOUT; // Timeout return srm_call_status_TIMEOUT; } return srm_call_status_INTERNAL_ERROR; case SRM_USCOREREQUEST_USCOREQUEUED: case SRM_USCOREREQUEST_USCOREINPROGRESS: if (wait_switch_auto(context,internal_context) != 0) { srm_errmsg (context, "[%s][%s][ETIMEDOUT] %s: User timeout over", err_msg_begin,srmfunc, context->srm_endpoint); errno = ETIMEDOUT; // Timeout return srm_call_status_TIMEOUT; } return srm_call_status_QUEUED; case SRM_USCORESUCCESS: case SRM_USCOREPARTIAL_USCORESUCCESS: // TODO return srm_call_status_SUCCESS; default: return srm_call_status_FAILURE; } } return srm_call_status_FAILURE; } void srm_spacemd_free (int nbtokens,struct srm_spacemd *smd) { int i; if (smd == NULL) return; for (i = 0; i < nbtokens; ++i) { if (smd[i].spacetoken) free (smd[i].spacetoken); if (smd[i].owner) free (smd[i].owner); } free (smd); } int srm_set_protocol_in_transferParameters( struct srm_context *context, struct soap* soap, struct srm2__TTransferParameters* transferParameters, char** protocols) { struct srm2__ArrayOfString ** array = NULL; assert(transferParameters); array = &(transferParameters->arrayOfTransferProtocols); *array = NULL; if (protocols) { *array = soap_malloc (soap, sizeof(struct srm2__ArrayOfString)); if (*array == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; return -1; } (*array)->__sizestringArray = srm_count_elements_of_string_array(protocols); (*array)->stringArray = protocols; } return 0; } char* srm_strip_string(const char* str, const char chr) { char *res = 0; assert(str); if (str) { char *pos = strrchr(str, chr); int size = -1; if (pos) { /* +1: to include the last character as well */ size = pos - str + 1; } else { size = strlen(str); } res = (char*) malloc(size + 1); strncpy(res, str, size); res[size] = 0; } return res; } int srm_count_elements_of_string_array(char** a) { int ret = -1; GFAL_SRM_IFCE_ASSERT(a); for (ret = 0; a[ret] != 0; ++ret) ; return ret; } int copy_string(char **dest,char *src) { GFAL_SRM_IFCE_ASSERT(dest); if (src) { *dest = strdup(src); if (*dest == NULL) { errno = ENOMEM; return (-1); } } else { *dest = NULL; errno = EINVAL; // queued but empty token return (-1); } return 0; } int copy_permissionfilestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_filestatus **statuses, struct srm2__ArrayOfTSURLPermissionReturn *repfs, const char *srmfunc, int amode) { int i,n; n = repfs->__sizesurlPermissionArray; if ((*statuses = (struct srmv2_filestatus *) calloc (n, sizeof(struct srmv2_filestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->surlPermissionArray[i]) continue; memset (*statuses + i, 0, sizeof (struct srmv2_filestatus)); if (repfs->surlPermissionArray[i]->surl) (*statuses)[i].surl = strdup (repfs->surlPermissionArray[i]->surl); if (repfs->surlPermissionArray[i]->status) { (*statuses)[i].status = statuscode2errno (repfs->surlPermissionArray[i]->status->statusCode); if (repfs->surlPermissionArray[i]->status->explanation && repfs->surlPermissionArray[i]->status->explanation[0]) (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->surlPermissionArray[i]->status->statusCode), repfs->surlPermissionArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->surlPermissionArray[i]->status->statusCode), reqstatp->explanation); else (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->surlPermissionArray[i]->status->statusCode)); } else (*statuses)[i].status = ENOMEM; if ((*statuses)[i].status == 0) { enum srm2__TPermissionMode perm = *(repfs->surlPermissionArray[i]->permission); if ((amode == R_OK && (perm == NONE || perm == X || perm == W || perm == WX)) || (amode == W_OK && (perm == NONE || perm == X || perm == R || perm == RX)) || (amode == X_OK && (perm == NONE || perm == W || perm == R || perm == RW)) || (amode == (R_OK|W_OK) && perm != RW && perm != RWX) || (amode == (R_OK|X_OK) && perm != RX && perm != RWX) || (amode == (W_OK|X_OK) && perm != WX && perm != RWX) || (amode == (R_OK|W_OK|X_OK) && perm != RWX)) (*statuses)[i].status = EACCES; } } return n; } int copy_filestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_filestatus **statuses, struct srm2__ArrayOfTSURLReturnStatus *repfs, const char *srmfunc) { int i,n; n = repfs->__sizestatusArray; if ((*statuses = (struct srmv2_filestatus *) calloc (n, sizeof(struct srmv2_filestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->statusArray[i]) continue; memset (*statuses + i, 0, sizeof (struct srmv2_filestatus)); if (repfs->statusArray[i]->surl) (*statuses)[i].surl = strdup (repfs->statusArray[i]->surl); if (repfs->statusArray[i]->status) { (*statuses)[i].status = statuscode2errno (repfs->statusArray[i]->status->statusCode); if (repfs->statusArray[i]->status->explanation && repfs->statusArray[i]->status->explanation[0]) (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), repfs->statusArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), reqstatp->explanation); else (void)asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode)); } } return n; } int copy_pinfilestatuses_extendlifetime(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTSURLLifetimeReturnStatus *repfs, const char *srmfunc) { int n,i; n = repfs->__sizestatusArray; if ((*filestatuses = (struct srmv2_pinfilestatus *) calloc (n, sizeof (struct srmv2_pinfilestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->statusArray[i]) continue; memset (*filestatuses + i, 0, sizeof (struct srmv2_pinfilestatus)); if (repfs->statusArray[i]->surl) { (*filestatuses)[i].surl = strdup (repfs->statusArray[i]->surl); } if (repfs->statusArray[i]->pinLifetime) { (*filestatuses)[i].pinlifetime = *(repfs->statusArray[i]->pinLifetime); } if (repfs->statusArray[i]->status) { (*filestatuses)[i].status = statuscode2errno (repfs->statusArray[i]->status->statusCode); if (repfs->statusArray[i]->status->explanation && repfs->statusArray[i]->status->explanation[0]) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), repfs->statusArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), reqstatp->explanation); else if ((*filestatuses)[i].status != 0) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode)); } } return n; } int copy_pinfilestatuses_get(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTGetRequestFileStatus *repfs, const char *srmfunc) { int n,i; n = repfs->__sizestatusArray; if ((*filestatuses = (struct srmv2_pinfilestatus *) calloc (n, sizeof (struct srmv2_pinfilestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->statusArray[i]) continue; memset (*filestatuses + i, 0, sizeof (struct srmv2_pinfilestatus)); if (repfs->statusArray[i]->sourceSURL) (*filestatuses)[i].surl = strdup (repfs->statusArray[i]->sourceSURL); if (repfs->statusArray[i]->transferURL) (*filestatuses)[i].turl = strdup (repfs->statusArray[i]->transferURL); if (repfs->statusArray[i]->status) { (*filestatuses)[i].status = statuscode2errno (repfs->statusArray[i]->status->statusCode); if (repfs->statusArray[i]->status->explanation && repfs->statusArray[i]->status->explanation[0]) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), repfs->statusArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), reqstatp->explanation); else if ((*filestatuses)[i].status != 0) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode)); } if (repfs->statusArray[i]->remainingPinTime) (*filestatuses)[i].pinlifetime = *(repfs->statusArray[i]->remainingPinTime); if (repfs->statusArray[i]->estimatedWaitTime) { (*filestatuses)[i].estimated_wait_time = *(repfs->statusArray[i]->estimatedWaitTime); }else { (*filestatuses)[i].estimated_wait_time = -1; } } return n; } int copy_pinfilestatuses_bringonline(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTBringOnlineRequestFileStatus *repfs, const char *srmfunc) { int n,i; n = repfs->__sizestatusArray; if ((*filestatuses = (struct srmv2_pinfilestatus *) calloc (n, sizeof (struct srmv2_pinfilestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->statusArray[i]) continue; memset (*filestatuses + i, 0, sizeof (struct srmv2_pinfilestatus)); if (repfs->statusArray[i]->sourceSURL) (*filestatuses)[i].surl = strdup (repfs->statusArray[i]->sourceSURL); if (repfs->statusArray[i]->status) { (*filestatuses)[i].status = statuscode2errno (repfs->statusArray[i]->status->statusCode); if (repfs->statusArray[i]->status->explanation && repfs->statusArray[i]->status->explanation[0]) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), repfs->statusArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), reqstatp->explanation); else if ((*filestatuses)[i].status != 0) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode)); } if (repfs->statusArray[i]->remainingPinTime) (*filestatuses)[i].pinlifetime = *(repfs->statusArray[i]->remainingPinTime); if (repfs->statusArray[i]->estimatedWaitTime) { (*filestatuses)[i].estimated_wait_time = *(repfs->statusArray[i]->estimatedWaitTime); }else { (*filestatuses)[i].estimated_wait_time = -1; } } return n; } int copy_pinfilestatuses_put(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTPutRequestFileStatus *repfs, const char *srmfunc) { int n,i; n = repfs->__sizestatusArray; if ((*filestatuses = (struct srmv2_pinfilestatus *) calloc (n, sizeof (struct srmv2_pinfilestatus))) == NULL) { errno = ENOMEM; return (-1); } for (i = 0; i < n; i++) { if (!repfs->statusArray[i]) continue; memset (*filestatuses + i, 0, sizeof (struct srmv2_pinfilestatus)); if (repfs->statusArray[i]->SURL) (*filestatuses)[i].surl = strdup (repfs->statusArray[i]->SURL); if (repfs->statusArray[i]->transferURL) (*filestatuses)[i].turl = strdup (repfs->statusArray[i]->transferURL); if (repfs->statusArray[i]->status) { (*filestatuses)[i].status = statuscode2errno (repfs->statusArray[i]->status->statusCode); if (repfs->statusArray[i]->status->explanation && repfs->statusArray[i]->status->explanation[0]) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), repfs->statusArray[i]->status->explanation); else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode), reqstatp->explanation); else if ((*filestatuses)[i].status != 0) (void) asprintf (&((*filestatuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg (repfs->statusArray[i]->status->statusCode)); } if (repfs->statusArray[i]->remainingPinLifetime) (*filestatuses)[i].pinlifetime = *(repfs->statusArray[i]->remainingPinLifetime); if (repfs->statusArray[i]->estimatedWaitTime) { (*filestatuses)[i].estimated_wait_time = *(repfs->statusArray[i]->estimatedWaitTime); }else { (*filestatuses)[i].estimated_wait_time = -1; } } return n; } int copy_filepermissions(struct srm2__TReturnStatus *reqstatp, struct srm_filepermission **permissions, struct srm2__ArrayOfTPermissionReturn *repperm) { int i, n, j , k; const char srmfunc[] = "GetPermission"; if (reqstatp == NULL || repperm == NULL || permissions == NULL) { errno = EFAULT; return (-1); } n = repperm->__sizepermissionArray; if ((*permissions = (struct srm_filepermission *) calloc (n, sizeof (struct srm_filepermission))) == NULL) { return (-1); } for (i = 0; i < n; ++i) { if (!repperm->permissionArray[i]) continue; memset (*permissions + i, 0, sizeof(struct srm_filepermission)); if (repperm->permissionArray[i]->owner) { (*permissions)[i].owner = strdup (repperm->permissionArray[i]->owner); } if (repperm->permissionArray[i]->surl) { (*permissions)[i].surl = strdup (repperm->permissionArray[i]->surl); } if (repperm->permissionArray[i]->status) { (*permissions)[i].status = statuscode2errno(repperm->permissionArray[i]->status->statusCode); if (repperm->permissionArray[i]->status->explanation && repperm->permissionArray[i]->status->explanation[0]) { asprintf (&((*permissions)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg(repperm->permissionArray[i]->status->statusCode), repperm->permissionArray[i]->status->explanation); }else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) { asprintf (&((*permissions)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg(repperm->permissionArray[i]->status->statusCode), reqstatp->explanation); }else { asprintf (&((*permissions)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg(repperm->permissionArray[i]->status->statusCode)); } //continue; } if (repperm->permissionArray[i]->ownerPermission) { (*permissions)[i].owner_permission = *repperm->permissionArray[i]->ownerPermission; } if (repperm->permissionArray[i]->otherPermission) { (*permissions)[i].other_permission = *repperm->permissionArray[i]->otherPermission; } if (repperm->permissionArray[i]->arrayOfGroupPermissions && repperm->permissionArray[i]->arrayOfGroupPermissions->__sizegroupPermissionArray>0) { k = repperm->permissionArray[i]->arrayOfGroupPermissions->__sizegroupPermissionArray; (*permissions)[i].group_permissions_count = k; if (( (*permissions)[i].group_permissions = (struct srm_permission *) calloc (k, sizeof (struct srm_permission))) == NULL) return (-1); for (j = 0; j < k; ++j) { if (repperm->permissionArray[i]->arrayOfGroupPermissions->groupPermissionArray[j] == NULL) continue; (*permissions)[i].group_permissions[j].name_id = strdup (repperm->permissionArray[i]->arrayOfGroupPermissions->groupPermissionArray[j]->groupID); (*permissions)[i].group_permissions[j].mode = repperm->permissionArray[i]->arrayOfGroupPermissions->groupPermissionArray[j]->mode; } }else { (*permissions)[i].group_permissions_count = 0; (*permissions)[i].group_permissions = NULL; } if (repperm->permissionArray[i]->arrayOfUserPermissions && repperm->permissionArray[i]->arrayOfUserPermissions->__sizeuserPermissionArray>0) { k = repperm->permissionArray[i]->arrayOfUserPermissions->__sizeuserPermissionArray; (*permissions)[i].user_permissions_count = k; if (( (*permissions)[i].user_permissions = (struct srm_permission *) calloc (k, sizeof (struct srm_permission))) == NULL) return (-1); for (j = 0; j < k; ++j) { if (repperm->permissionArray[i]->arrayOfUserPermissions->userPermissionArray[j] == NULL) continue; (*permissions)[i].user_permissions[j].name_id = strdup (repperm->permissionArray[i]->arrayOfUserPermissions->userPermissionArray[j]->userID); (*permissions)[i].user_permissions[j].mode = repperm->permissionArray[i]->arrayOfUserPermissions->userPermissionArray[j]->mode; } }else { (*permissions)[i].user_permissions_count = 0; (*permissions)[i].user_permissions = NULL; } } errno = 0; return (n); } /** * Copy TLocality (ONLINE, NEARLINE,...) from srm soap to srmifce enum */ void copy_Locality(struct srm2__TMetaDataPathDetail *soap_file_meta_data, struct srmv2_mdfilestatus *statuses){ enum srm2__TFileLocality loc = *(soap_file_meta_data->fileLocality); TFileLocality res_loc; switch(loc){ case ONLINE_: res_loc = GFAL_LOCALITY_ONLINE_; break; case NEARLINE_: res_loc = GFAL_LOCALITY_NEARLINE_; break; case ONLINE_USCOREAND_USCORENEARLINE: res_loc = GFAL_LOCALITY_ONLINE_USCOREAND_USCORENEARLINE; break; case LOST: res_loc = GFAL_LOCALITY_LOST; break; case UNAVAILABLE: res_loc = GFAL_LOCALITY_UNAVAILABLE; break; default: res_loc = GFAL_LOCALITY_UNKNOWN; } statuses->locality = res_loc; } int copy_mdfilestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_mdfilestatus **statuses, struct srm2__ArrayOfTMetaDataPathDetail *repfs) { int i, n, r; const char srmfunc[] = "Ls"; if (reqstatp == NULL || repfs == NULL || statuses == NULL) { errno = EFAULT; return (-1); } n = repfs->__sizepathDetailArray; if ((*statuses = (struct srmv2_mdfilestatus *) calloc (n, sizeof (struct srmv2_mdfilestatus))) == NULL) { return (-1); } for (i = 0; i < n; ++i) { if (!repfs->pathDetailArray[i]) continue; memset (*statuses + i, 0, sizeof(struct srmv2_mdfilestatus)); if (repfs->pathDetailArray[i]->path) { (*statuses)[i].surl = strdup (repfs->pathDetailArray[i]->path); } if (repfs->pathDetailArray[i]->status) { (*statuses)[i].status = statuscode2errno(repfs->pathDetailArray[i]->status->statusCode); if ((*statuses)[i].status) { if (repfs->pathDetailArray[i]->status->explanation && repfs->pathDetailArray[i]->status->explanation[0]) { (void) asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg(repfs->pathDetailArray[i]->status->statusCode), repfs->pathDetailArray[i]->status->explanation); }else if (reqstatp->explanation != NULL && reqstatp->explanation[0] && strncasecmp (reqstatp->explanation, "failed for all", 14)) { (void) asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] %s",err_msg_begin, srmfunc, statuscode2errmsg(repfs->pathDetailArray[i]->status->statusCode), reqstatp->explanation); }else { (void) asprintf (&((*statuses)[i].explanation), "[%s][%s][%s] ",err_msg_begin, srmfunc, statuscode2errmsg(repfs->pathDetailArray[i]->status->statusCode)); } continue; } } if (repfs->pathDetailArray[i]->size) { (*statuses)[i].stat.st_size = *(repfs->pathDetailArray[i]->size); }else { (*statuses)[i].stat.st_size = 0; } if (repfs->pathDetailArray[i]->fileLocality) { copy_Locality(repfs->pathDetailArray[i], &((*statuses)[i]) ); } (*statuses)[i].stat.st_uid = 2;//TODO: create haseh placeholder for string<->uid/gid mapping (*statuses)[i].stat.st_gid = 2; (*statuses)[i].stat.st_nlink = 1; if (repfs->pathDetailArray[i]->otherPermission) { (*statuses)[i].stat.st_mode = *(repfs->pathDetailArray[i]->otherPermission); } if (repfs->pathDetailArray[i]->groupPermission) { (*statuses)[i].stat.st_mode |= repfs->pathDetailArray[i]->groupPermission->mode << 3; } if (repfs->pathDetailArray[i]->ownerPermission) { (*statuses)[i].stat.st_mode |= repfs->pathDetailArray[i]->ownerPermission->mode << 6; } if (repfs->pathDetailArray[i]->createdAtTime) { struct tm createdAtTime; strptime(repfs->pathDetailArray[i]->createdAtTime, "%Y-%m-%dT%T", &createdAtTime); (*statuses)[i].stat.st_ctime = mktime(&createdAtTime); } if (repfs->pathDetailArray[i]->lastModificationTime) { struct tm modifiedTime; strptime(repfs->pathDetailArray[i]->lastModificationTime, "%Y-%m-%dT%T", &modifiedTime); (*statuses)[i].stat.st_mtime = mktime(&modifiedTime); } if (repfs->pathDetailArray[i]->type) { switch (*(repfs->pathDetailArray[i]->type)) { case FILE_: (*statuses)[i].stat.st_mode |= S_IFREG; break; case DIRECTORY: (*statuses)[i].stat.st_mode |= S_IFDIR; break; case LINK: (*statuses)[i].stat.st_mode |= S_IFLNK; break; } } if (repfs->pathDetailArray[i]->checkSumType && repfs->pathDetailArray[i]->checkSumValue) { (*statuses)[i].checksumtype = strdup (repfs->pathDetailArray[i]->checkSumType); (*statuses)[i].checksum = strdup (repfs->pathDetailArray[i]->checkSumValue); } if (repfs->pathDetailArray[i]->arrayOfSpaceTokens && repfs->pathDetailArray[i]->arrayOfSpaceTokens->__sizestringArray > 0 && repfs->pathDetailArray[i]->arrayOfSpaceTokens->stringArray) { int j; (*statuses)[i].nbspacetokens = repfs->pathDetailArray[i]->arrayOfSpaceTokens->__sizestringArray; if (((*statuses)[i].spacetokens = (char **) calloc ((*statuses)[i].nbspacetokens, sizeof (char *))) == NULL) return (-1); for (j = 0; j < (*statuses)[i].nbspacetokens; ++j) { if (repfs->pathDetailArray[i]->arrayOfSpaceTokens->stringArray[j] == NULL) continue; (*statuses)[i].spacetokens[j] = strdup (repfs->pathDetailArray[i]->arrayOfSpaceTokens->stringArray[j]); } } if (repfs->pathDetailArray[i]->arrayOfSubPaths) { r = copy_mdfilestatuses (reqstatp, &((*statuses)[i].subpaths), repfs->pathDetailArray[i]->arrayOfSubPaths ); if (r < 0) return (r); (*statuses)[i].nbsubpaths = r; } } errno = 0; return (n); } int copy_returnstatus(struct srm2__TReturnStatus **destination,struct srm2__TReturnStatus *returnStatus) { if (returnStatus) { GFAL_SRM_IFCE_ASSERT(destination); *destination = (struct srm2__TReturnStatus *) malloc (sizeof (struct srm2__TReturnStatus)); if ((*destination) != NULL) { (**destination).explanation = NULL; if (returnStatus->explanation) { if (((**destination).explanation = strdup(returnStatus->explanation)) == NULL) { errno = ENOMEM; return (-1); } } (**destination).statusCode = returnStatus->statusCode; return 0; }else { errno = ENOMEM; return (-1); } }else { return -1; // empty response } return 0; } char* srm_util_consolidate_multiple_characters(const char* s, const char c, const int start) { char *tmp = 0; char *ret = 0; int i = 0; int tmp_i = 0; if (s == 0) { return 0; } tmp = (char*) malloc (strlen(s) + 1); for (; s[i] != 0; ++i) { // Copy the characters unless we find c. If the index + 1 also stores c, do not copy, if (i < start || s[i] != c || s[i + 1] != c) { tmp[tmp_i] = s[i]; ++tmp_i; } } tmp[tmp_i] = 0; // strdup the string, to shrink to the real size ret = strdup(tmp); free(tmp); return ret; } char* srm_util_add_strings(const char* s1, const char* s2) { char* ret = 0; unsigned int len_s1 = 0; assert(s1); assert(s2); if (!s1 || !s2) { return 0; } len_s1 = strlen(s1); ret = malloc(len_s1 + strlen(s2) + 1); assert(ret); if (ret) { strcpy(ret, s1); strcat(ret + len_s1, s2); } return ret; } char* srm_util_normalize_surl(const char* surl) { char *consolidated_file = NULL; char *with_trailing_slash = NULL; /* We put a trailing "/" to the end of each directory, fo fix the algorithm in srmv2_makedirp (Savannah bug #52502) */ with_trailing_slash = srm_util_add_strings(surl, "/"); assert(with_trailing_slash); /* do not consolidate the "//" after the protocol part... (srm://...) */ consolidated_file = srm_util_consolidate_multiple_characters( with_trailing_slash, '/', strlen("srm://") + 1); assert(consolidated_file); free(with_trailing_slash); return consolidated_file; } srm-ifce-1.18.0/src/srm_version_wrapper.c0000644001662700052000000002266312217066060017352 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include "gfal_srm_ifce.h" #include "srmv2_async_wrapper.h" #include "srmv2_sync_wrapper.h" #include "srm_ifce_internal.h" int srm_ls(struct srm_context *context,struct srm_ls_input *input,struct srm_ls_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_ls_sync(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_ls_async(struct srm_context *context,struct srm_ls_input *input,struct srm_ls_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_ls_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_status_of_ls_async(struct srm_context *context,struct srm_ls_input *input,struct srm_ls_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_status_of_ls_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_bring_online(struct srm_context *context,struct srm_bringonline_input *input,struct srm_bringonline_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_bring_online_sync(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_bring_online_async(struct srm_context *context,struct srm_bringonline_input *input,struct srm_bringonline_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_bring_online_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_status_of_bring_online_async(struct srm_context *context,struct srm_bringonline_input *input,struct srm_bringonline_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_status_of_bring_online_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_rm(struct srm_context *context,struct srm_rm_input *input,struct srm_rm_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_rm(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_rmdir(struct srm_context *context,struct srm_rmdir_input *input,struct srm_rmdir_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_rmdir(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_mkdir(struct srm_context *context,struct srm_mkdir_input *input) { switch (context->version) { case VERSION_2_2: return srmv2_mkdir(context,input); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_mv(struct srm_context *context, struct srm_mv_input *input) { switch (context->version) { case VERSION_2_2: return srmv2_mv(context,input); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_release_files(struct srm_context *context, struct srm_releasefiles_input *input, struct srmv2_filestatus **statuses) { switch (context->version) { case VERSION_2_2: return srmv2_release_files(context,input,statuses); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_put_done(struct srm_context *context, struct srm_putdone_input *input, struct srmv2_filestatus **statuses) { switch (context->version) { case VERSION_2_2: return srmv2_put_done(context,input,statuses); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_prepare_to_get(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_prepare_to_get_sync(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_prepare_to_get_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_prepare_to_get_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_status_of_get_request_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_status_of_get_request_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_prepare_to_put(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_prepare_to_put_sync(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_prepare_to_put_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_prepare_to_put_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_status_of_put_request_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_status_of_put_request_async(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_abort_files(struct srm_context *context, struct srm_abort_files_input *input,struct srmv2_filestatus **statuses) { switch (context->version) { case VERSION_2_2: return srmv2_abort_files(context,input,statuses); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_abort_request(struct srm_context *context, char *token) { switch (context->version) { case VERSION_2_2: return srmv2_abort_request(context,token); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_ping(struct srm_context *context, struct srm_ping_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_ping(context,output); case VERSION_1: // TODO return (-1); default: return (-1); } } char* srm_getbestspacetoken (struct srm_context *context, struct srm_getbestspacetokens_input *input) { switch (context->version) { case VERSION_2_2: return srmv2_getbestspacetoken(context,input); case VERSION_1: // TODO return (NULL); default: return (NULL); } } int srm_getspacetokens (struct srm_context *context, struct srm_getspacetokens_input *input,struct srm_getspacetokens_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_getspacetokens(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_getspacemd (struct srm_context *context, struct srm_getspacemd_input *input,struct srm_spacemd **spaces) { switch (context->version) { case VERSION_2_2: return srmv2_getspacemd(context,input,spaces); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_getpermission (struct srm_context *context, struct srm_getpermission_input *input,struct srm_getpermission_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_get_permission(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_setpermission (struct srm_context *context, struct srm_setpermission_input *input) { switch (context->version) { case VERSION_2_2: return srmv2_set_permission(context,input); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_extend_file_lifetime (struct srm_context *context, struct srm_extendfilelifetime_input *input, struct srm_extendfilelifetime_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_extend_file_lifetime(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_check_permission(struct srm_context *context, struct srm_checkpermission_input *input, struct srmv2_filestatus **statuses) { switch (context->version) { case VERSION_2_2: return srmv2_check_permission(context,input,statuses); case VERSION_1: // TODO return (-1); default: return (-1); } } int srm_purgefromspace(struct srm_context *context, struct srm_purgefromspace_input *input, struct srm_purgefromspace_output *output) { switch (context->version) { case VERSION_2_2: return srmv2_purgefromspace(context,input,output); case VERSION_1: // TODO return (-1); default: return (-1); } } srm-ifce-1.18.0/src/gfal_srm_ifce.h0000644001662700052000000001344612217066060016030 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #ifndef _SRM_IFCE_H #define _SRM_IFCE_H #include #include "gfal_srm_ifce_types.h" /** @brief create a srm_context srm context are used by all the srm operations need to be free with @ref srm_context_free after usage */ srm_context_t srm_context_new(const char * srm_endpoint, char *errbuf,int errbufsz,int verbose); srm_context_t srm_context_new2(const char * srm_endpoint, char *errbuf,int errbufsz,int verbose, int keep_alive); /** free resources used by a srm context */ void srm_context_free(srm_context_t context); /** brief : old compatibility : deprecated */ void srm_context_init(struct srm_context *context,char *srm_endpoint,char *errbuf,int errbufsz,int verbose); void srm_context_init2(struct srm_context *context,char *srm_endpoint,char *errbuf,int errbufsz,int verbose, int keep_alive); /* srm_ls functions */ void srm_ls_output_destroy(struct srm_ls_output *output); int srm_ls(struct srm_context *context, struct srm_ls_input *input,struct srm_ls_output *output); int srm_ls_async(struct srm_context *context, struct srm_ls_input *input,struct srm_ls_output *output); int srm_status_of_ls_async(struct srm_context *context, struct srm_ls_input *input,struct srm_ls_output *output); int srm_bring_online(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output); int srm_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input,struct srm_bringonline_output *output); int srm_status_of_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input,struct srm_bringonline_output *output); int srm_prepare_to_put(struct srm_context *context, struct srm_preparetoput_input *input,struct srm_preparetoput_output *output); int srm_prepare_to_put_async(struct srm_context *context, struct srm_preparetoput_input *input,struct srm_preparetoput_output *output); int srm_status_of_put_request_async(struct srm_context *context, struct srm_preparetoput_input *input,struct srm_preparetoput_output *output); int srm_prepare_to_get(struct srm_context *context, struct srm_preparetoget_input *input,struct srm_preparetoget_output *output); int srm_prepare_to_get_async(struct srm_context *context, struct srm_preparetoget_input *input,struct srm_preparetoget_output *output); int srm_status_of_get_request_async(struct srm_context *context, struct srm_preparetoget_input *input,struct srm_preparetoget_output *output); int srm_rm(struct srm_context *context, struct srm_rm_input *input,struct srm_rm_output *output); int srm_rmdir(struct srm_context *context, struct srm_rmdir_input *input,struct srm_rmdir_output *output); int srm_mkdir(struct srm_context *context, struct srm_mkdir_input *input); int srm_mv(struct srm_context *context, struct srm_mv_input *input); int srm_put_done(struct srm_context *context, struct srm_putdone_input *input, struct srmv2_filestatus **statuses); int srm_release_files(struct srm_context *context, struct srm_releasefiles_input *input, struct srmv2_filestatus **statuses); int srm_abort_files(struct srm_context *context, struct srm_abort_files_input *input,struct srmv2_filestatus **statuses); int srm_abort_request (struct srm_context *context, char *reqtoken); char* srm_getbestspacetoken (struct srm_context *context, struct srm_getbestspacetokens_input *input); int srm_getspacetokens (struct srm_context *context, struct srm_getspacetokens_input *input,struct srm_getspacetokens_output *output); int srm_getspacemd (struct srm_context *context, struct srm_getspacemd_input *input,struct srm_spacemd **spaces); int srm_ping(struct srm_context *context, struct srm_ping_output *output); int srm_getpermission (struct srm_context *context, struct srm_getpermission_input *input,struct srm_getpermission_output *output); int srm_setpermission (struct srm_context *context, struct srm_setpermission_input *input); int srm_check_permission(struct srm_context *context, struct srm_checkpermission_input *input,struct srmv2_filestatus **statuses); char* srmv2_getbestspacetoken (struct srm_context *context, struct srm_getbestspacetokens_input *input); int srm_extend_file_lifetime (struct srm_context *context, struct srm_extendfilelifetime_input *input,struct srm_extendfilelifetime_output *output); int srm_purgefromspace(struct srm_context *context, struct srm_purgefromspace_input *input,struct srm_purgefromspace_output *output); // memory management void srm_srmv2_pinfilestatus_delete(struct srmv2_pinfilestatus* srmv2_pinstatuses, int n); void srm_srmv2_mdfilestatus_delete(struct srmv2_mdfilestatus* mdfilestatus, int n); void srm_srmv2_filestatus_delete(struct srmv2_filestatus* srmv2_statuses, int n); void srm_srm2__TReturnStatus_delete(struct srm2__TReturnStatus* status); // gsoap timeouts void srm_set_timeout_connect (int); int srm_get_timeout_connect (); void srm_set_timeout_sendreceive (int); int srm_get_timeout_sendreceive (); #endif srm-ifce-1.18.0/src/gfal_srm_ifce_types.h0000644001662700052000000002537712217066060017262 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #ifndef _SRM_TYPES_H #define _SRM_TYPES_H #include #include #include #include #include #ifndef SRM_LONG64_FORMAT #if defined(__ia64__) || defined(__x86_64) #define SRM_LONG64_FORMAT "%ld" #elif defined(_WIN32) #define SRM_LONG64_FORMAT "%I64d" #else #define SRM_LONG64_FORMAT "%lld" #endif #endif #ifndef SRM_LONG64 #define SRM_LONG64 gint64 #endif #define SRM_SIZE_MARGIN 1048576 // 1MB #ifndef ECOMM #define ECOMM EIO #endif typedef struct srm_context* srm_context_t; typedef struct srm_context_extension* srm_context_extension_t; enum TFileLocality_ { GFAL_LOCALITY_UNKNOWN = 0, GFAL_LOCALITY_ONLINE_, ///< xs:string value="ONLINE" GFAL_LOCALITY_NEARLINE_, ///< xs:string value="NEARLINE" GFAL_LOCALITY_ONLINE_USCOREAND_USCORENEARLINE, ///< xs:string value="ONLINE_AND_NEARLINE" GFAL_LOCALITY_LOST, ///< xs:string value="LOST" GFAL_LOCALITY_NONE_, ///< xs:string value="NONE" GFAL_LOCALITY_UNAVAILABLE ///< xs:string value="UNAVAILABLE" }; /// Typedef synonym for enum ns1__TFileLocality. typedef enum TFileLocality_ TFileLocality; enum TRetentionPolicy_ { GFAL_POLICY_UNKNOWN = 0, GFAL_POLICY_REPLICA, GFAL_POLICY_OUTPUT, GFAL_POLICY_CUSTODIAL }; /// Typedef synonym for enum ns1__TRetentionPolicy. typedef enum TRetentionPolicy_ TRetentionPolicy; enum TAccessLatency_ { GFAL_LATENCY_UNKNOWN = 0, GFAL_LATENCY_ONLINE, GFAL_LATENCY_NEARLINE }; /// Typedef synonym for enum ns1__TAccessLatency. typedef enum TAccessLatency_ TAccessLatency; enum TPermissionType_ { SRM_PERMISSION_ADD = 0, SRM_PERMISSION_REMOVE = 1, SRM_PERMISSION_CHANGE = 2 }; typedef enum TPermissionType_ TPermissionType; enum TPermissionMode_ { SRM_PERMISSION_NONE = 0, SRM_PERMISSION_X = 1, SRM_PERMISSION_W = 2, SRM_PERMISSION_WX = 3, SRM_PERMISSION_R = 4, SRM_PERMISSION_RX = 5, SRM_PERMISSION_RW = 6, SRM_PERMISSION_RWX = 7 }; typedef enum TPermissionMode_ TPermissionMode; enum srm_version { VERSION_1, VERSION_2_2, }; enum srm_call_status_ { srm_call_status_SUCCESS = 0, srm_call_status_FAILURE = 1, srm_call_status_TIMEOUT = 2, srm_call_status_QUEUED = 3, srm_call_status_INTERNAL_ERROR = 4 }; typedef enum srm_call_status_ srm_call_status; struct srm_filestatus { char *surl; char *turl; int fileid; int status; }; struct srmv2_pinfilestatus { char *surl; // surl of the file char *turl; // turl of the file int status; // status code char *explanation; // string for the status int pinlifetime; // pin lifetime int estimated_wait_time; }; struct srmv2_filestatus { char *surl; // surl of the file char *turl; // turl of the file int status; // status code char *explanation; // string for the status }; struct srm_context { enum srm_version version; char * srm_endpoint; char * errbuf; int errbufsz; int verbose; int timeout; // global timeout for asynchronous operations int timeout_conn; // global timeout for SOAP connection int timeout_ops; // global timeout for response on operation ( send/receive ) srm_context_extension_t ext; void* reserved[24]; // reserved field for futur usage }; struct srm_internal_context { srm_call_status current_status; time_t end_time; time_t relative_timeout; struct timespec end_time_spec; struct timespec current_waittime_spec; int attempt; int estimated_wait_time; unsigned int random_seed; }; struct srm_ls_input { int nbfiles; // number of surls in the array char **surls; // array of surls int numlevels; int *offset; int count; }; struct srm_ping_output { char *versioninfo; // srm server version information }; #if ! defined(linux) || defined(_LARGEFILE64_SOURCE) struct srm_mdfilestatus { char *surl; struct stat64 stat; int fileid; int status; }; struct srmv2_mdfilestatus { char *surl; struct stat64 stat; int status; char *explanation; struct srmv2_mdfilestatus *subpaths; int nbsubpaths; TFileLocality locality; char *checksumtype; char *checksum; char **spacetokens; int nbspacetokens; }; #endif struct srm_ls_output { struct srmv2_mdfilestatus *statuses; char *token; // request token struct srm2__TReturnStatus *retstatus; int statuses_num; }; struct srm_rm_input { int nbfiles; // number of surls in the array char **surls; // array of surls }; struct srm_rm_output { struct srm2__TReturnStatus *retstatus; // status of the srm call struct srmv2_filestatus *statuses; // returned file statuses }; struct srm_rmdir_input { int recursive; // recursive(1) or not(0) char *surl; // directory surl }; struct srm_rmdir_output { struct srm2__TReturnStatus *retstatus; // status of the srm call struct srmv2_filestatus *statuses; }; struct srm_mkdir_input { char *dir_name; // directory surl }; struct srm_mv_input { char *from; char *to; }; struct srm_preparetoget_input { int nbfiles; // number of surls in the array char **surls; // array of surls int desiredpintime; // desired pin time char *spacetokendesc; // space token descriptor char **protocols; // protocols used }; struct srm_preparetoput_input { SRM_LONG64 *filesizes; // filesize int nbfiles; // number of surls in the array char **surls; // array of surls int desiredpintime; // desired pin time char *spacetokendesc; // space token descriptor char **protocols;// protocols used }; struct srm_preparetoget_output { char *token; // request token struct srm2__TReturnStatus *retstatus; // status of the srm call struct srmv2_pinfilestatus *filestatuses; // returned statuses }; struct srm_preparetoput_output { char *token;// request token struct srm2__TReturnStatus *retstatus; // status of the srm call struct srmv2_pinfilestatus *filestatuses;// returned statuses }; struct srm_putdone_input { int nbfiles; // number of surls in the array char **surls; // array of surls char *reqtoken; // request token }; struct srm_releasefiles_input { int nbfiles; // number of surls in the array char **surls; // array of surls char *reqtoken; // request token }; struct srm_abort_files_input { int nbfiles; // number of surls in the array char **surls; // array of surls char *reqtoken; // request token }; struct srm_bringonline_input { int nbfiles; // number of surls in the array char **surls; // array of surls int desiredpintime; // desired pin time char *spacetokendesc; // space token descriptor char **protocols; // protocols used }; struct srm_bringonline_output { char *token;// request token struct srm2__TReturnStatus *retstatus;// status of the srm call struct srmv2_pinfilestatus *filestatuses;// returned statuses }; struct srm_getspacetokens_input { char *spacetokendesc; // space token descriptor }; struct srm_getspacetokens_output { int nbtokens; // number of space tokens in the array char **spacetokens; // array of space tokens }; struct srm_getspacemd_input { int nbtokens; // number of space tokens in the array char **spacetokens; // array of space tokens }; struct srm_getbestspacetokens_input { char *spacetokendesc; // space token descriptor SRM_LONG64 neededsize; // required space }; struct srm_permission { char *name_id; // name id string TPermissionMode mode; // permission mode }; struct srm_setpermission_input { char *surl; // surl to set the permission properties for TPermissionType permission_type; // add/change/remove TPermissionMode owner_permission; // owner permission TPermissionMode other_permission; // other users permission int user_permissions_count; // user permissions size of array struct srm_permission *user_permissions; // array of user permissions int group_permissions_count; // group permissions size of array struct srm_permission *group_permissions; // array of group permissions }; struct srm_getpermission_input { int nbfiles; // number of surls in the array char **surls; // array of surls }; struct srm_checkpermission_input { int amode; int nbfiles; // number of surls in the array char **surls; // array of surls }; struct srm_extendfilelifetime_input { int nbfiles; // number of surls in the array char **surls; // array of surls char *reqtoken; // request token int pintime; // pin time }; struct srm_extendfilelifetime_output { struct srm2__TReturnStatus *retstatus;// status of the srm call struct srmv2_pinfilestatus *filestatuses;// returned statuses }; struct srm_filepermission { char *surl; int status; char *explanation; char *owner; TPermissionMode owner_permission; TPermissionMode other_permission; int user_permissions_count; struct srm_permission *user_permissions; int group_permissions_count; struct srm_permission *group_permissions; }; struct srm_getpermission_output { struct srm2__TReturnStatus *retstatus;// status of the srm call struct srm_filepermission *permissions;// array of file permissions }; struct srm_spacemd { char *spacetoken; // space token string char *owner; // name of the owner SRM_LONG64 totalsize; // total size of the space SRM_LONG64 guaranteedsize; // guaranteed size of the space SRM_LONG64 unusedsize; // unused space int lifetimeassigned; // life time assigned to the space int lifetimeleft; // total time left TRetentionPolicy retentionpolicy; TAccessLatency accesslatency; }; struct srm_reservespace_input { char *spacetokendescriptor; // space token descriptor int desired_lifetime; // desired lifetime SRM_LONG64 desired_size; // desired size }; struct srm_reservespace_output { struct srm2__TReturnStatus *retstatus; char *spacetoken; // space token int lifetime; // lifetime of the space token SRM_LONG64 size_total; // total size of the space SRM_LONG64 size_guaranteed; // guaranteed size of the space }; struct srm_purgefromspace_input { int nbfiles; // number of surls in the array char **surls; // array of surls char *spacetoken; // space token }; struct srm_purgefromspace_output { struct srm2__TReturnStatus *retstatus; // status of the srm call struct srmv2_filestatus *statuses; }; #endif /* _SRM_TYPES_H */ srm-ifce-1.18.0/src/srmv2_async_wrapper.h0000644001662700052000000000374712217066060017261 0ustar adevresscg#pragma once #ifndef _SRMV2_ASYNC_WRAPPER_H_ #define _SRMV2_ASYNC_WRAPPER_H_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_ls_async(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output); int srmv2_status_of_ls_async(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output); int srmv2_prepare_to_get_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output); int srmv2_status_of_get_request_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output); int srmv2_prepare_to_put_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output); int srmv2_status_of_put_request_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output); int srmv2_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output); int srmv2_status_of_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output); #endif srm-ifce-1.18.0/src/gfal_srm_ifce_memory_functions.c0000644001662700052000000000564712217066060021507 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include #include #include #include #include "srm_soap.h" #include "gfal_srm_ifce_types.h" #include "srmv2H.h" #include "srm_dependencies.h" /** * @file file for the memory management help functions * @version 0.0.1 * @date 09/06/2011 * @author Adrien Devresse */ /** * @brief delete properly and free memory for a number n of of struct srmv2_pinstatuses * If called on a NULL value, simply return **/ void srm_srmv2_pinfilestatus_delete(struct srmv2_pinfilestatus* srmv2_pinstatuses, int n){ if(srmv2_pinstatuses){ int i ; for(i=0; i < n; ++i){ free(srmv2_pinstatuses[i].surl); free(srmv2_pinstatuses[i].turl); free(srmv2_pinstatuses[i].explanation); } free(srmv2_pinstatuses); } } /** * @brief delete properly and free memory for a number n of struct srmv2_mdfilestatus * If called on a NULL value, simply return **/ void srm_srmv2_mdfilestatus_delete(struct srmv2_mdfilestatus* mdfilestatus, int n){ if(mdfilestatus){ int i,j ; for(i=0; i < n; ++i){ free(mdfilestatus[i].surl); free(mdfilestatus[i].explanation); free(mdfilestatus[i].checksum); free(mdfilestatus[i].checksumtype); for(j=0; j < mdfilestatus[i].nbspacetokens;++j){ if(mdfilestatus && mdfilestatus[i].spacetokens[i] ){ free(mdfilestatus[i].spacetokens[i]); mdfilestatus[i].spacetokens[i]=NULL; } } srm_srmv2_mdfilestatus_delete(mdfilestatus[i].subpaths, mdfilestatus[i].nbsubpaths); } free(mdfilestatus); } } /** * @brief delete properly and free memory for a number n of struct srmv2_filestatuses * If called on a NULL value, simply return **/ void srm_srmv2_filestatus_delete(struct srmv2_filestatus* srmv2_statuses, int n){ if(srmv2_statuses){ int i; for(i=0; i < n; ++i){ free(srmv2_statuses[i].surl); free(srmv2_statuses[i].turl); free(srmv2_statuses[i].explanation); } free(srmv2_statuses); } } /** * * @brief delete properly and free memory for a struct srm2__TReturnStatus * If called on a NULL value, simply return */ void srm_srm2__TReturnStatus_delete(struct srm2__TReturnStatus* status){ if(status){ free(status->explanation); free(status); } } srm-ifce-1.18.0/src/srmv2_data_transfer_functions.c0000644001662700052000000011366512217066060021305 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" #include "srm_soap.h" int srmv2_put_status_estimated_wait_time(struct srm2__srmStatusOfPutRequestResponse_ *prepareToPutStatusRep){ if( prepareToPutStatusRep && prepareToPutStatusRep->srmStatusOfPutRequestResponse && prepareToPutStatusRep->srmStatusOfPutRequestResponse->arrayOfFileStatuses && prepareToPutStatusRep->srmStatusOfPutRequestResponse->arrayOfFileStatuses->__sizestatusArray > 0 && prepareToPutStatusRep->srmStatusOfPutRequestResponse->arrayOfFileStatuses->statusArray){ struct srm2__TPutRequestFileStatus* status= *prepareToPutStatusRep->srmStatusOfPutRequestResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime){ return *status->estimatedWaitTime; } } return -1; } int srmv2_status_of_put_request_async_internal(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output, struct srm_internal_context *internal_context) { struct srm2__ArrayOfTPutRequestFileStatus *repfs; int ret = 0; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmStatusOfPutRequestResponse_ srep; struct srm2__srmStatusOfPutRequestRequest sreq; const char srmfunc[] = "StatusOfPutRequest"; memset (&sreq, 0, sizeof(sreq)); sreq.requestToken = output->token; output->retstatus = NULL; output->filestatuses = NULL; do { ret = call_function.call_srm2__srmStatusOfPutRequest(soap, context->srm_endpoint, srmfunc, &sreq, &srep); // If no response break with failure if ((srep.srmStatusOfPutRequestResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,srep.srmStatusOfPutRequestResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_put_status_estimated_wait_time(&srep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); repfs = srep.srmStatusOfPutRequestResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); if (output->retstatus->statusCode == SRM_USCORESPACE_USCORELIFETIME_USCOREEXPIRED) { srm_errmsg (context,"[SRM][%s][%s] %s: Space lifetime expired",srmfunc, statuscode2errmsg(output->retstatus->statusCode), context->srm_endpoint); errno = statuscode2errno(output->retstatus->statusCode); srm_soap_free(soap); return (-1); } switch (internal_context->current_status) { case srm_call_status_QUEUED: break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { errno = 0; internal_context->current_status = srm_call_status_SUCCESS; ret = copy_pinfilestatuses_put(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_TIMEOUT: errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_put_estimated_wait_time(struct srm2__srmPrepareToPutResponse_ *prepareToPutRep){ if(prepareToPutRep && prepareToPutRep->srmPrepareToPutResponse && prepareToPutRep->srmPrepareToPutResponse->arrayOfFileStatuses && prepareToPutRep->srmPrepareToPutResponse->arrayOfFileStatuses->__sizestatusArray > 0 && prepareToPutRep->srmPrepareToPutResponse->arrayOfFileStatuses->statusArray){ struct srm2__TPutRequestFileStatus * status = *prepareToPutRep->srmPrepareToPutResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime){ return *status->estimatedWaitTime; } } return -1; } int srmv2_prepare_to_put_async_internal(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output, struct srm_internal_context *internal_context) { int i; int ret = 0; struct srm2__srmPrepareToPutResponse_ rep; struct srm2__ArrayOfTPutRequestFileStatus *repfs; struct srm2__srmPrepareToPutRequest req; struct soap* soap = srm_soap_init_context_new(context); static enum srm2__TFileStorageType s_types[] = {VOLATILE, DURABLE, PERMANENT}; char *targetspacetoken; const char srmfunc[] = "PrepareToPut"; struct srm_getbestspacetokens_input spacetokeninput; SRM_LONG64 totalsize=0; memset (&req, 0, sizeof(req)); memset (&rep, 0, sizeof(rep)); memset(output,0,sizeof(*output)); if ((req.arrayOfFileRequests = soap_malloc (soap, sizeof(struct srm2__ArrayOfTPutFileRequest))) == NULL || (req.arrayOfFileRequests->requestArray = soap_malloc (soap, input->nbfiles* sizeof(struct srm2__TPutFileRequest *))) == NULL || (req.transferParameters = soap_malloc (soap, sizeof(struct srm2__TTransferParameters))) == NULL || (req.targetSpaceToken = soap_malloc (soap, sizeof(char *))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } if(context->ext && context->ext->turl_timeout){ // advanced context -> turl timeout req.desiredPinLifeTime = &(context->ext->turl_timeout); req.desiredTotalRequestTime = &(context->ext->turl_timeout); }else{ if (input->desiredpintime > 0) req.desiredPinLifeTime = &input->desiredpintime; else req.desiredPinLifeTime = &context->timeout_ops; if (context->timeout_ops > 0) req.desiredTotalRequestTime = &context->timeout_ops; } req.desiredFileStorageType = &s_types[PERMANENT]; req.arrayOfFileRequests->__sizerequestArray = input->nbfiles; if (input->filesizes == NULL && input->nbfiles>0) { errno = EINVAL; srm_soap_free(soap); return (-1); } for (i = 0; i < input->nbfiles; i++) { if ((req.arrayOfFileRequests->requestArray[i] = soap_malloc (soap, sizeof(struct srm2__TPutFileRequest))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } memset (req.arrayOfFileRequests->requestArray[i], 0, sizeof(struct srm2__TPutFileRequest)); req.arrayOfFileRequests->requestArray[i]->targetSURL = (char *)input->surls[i]; if ((req.arrayOfFileRequests->requestArray[i]->expectedFileSize = soap_malloc (soap, sizeof(ULONG64))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } *(req.arrayOfFileRequests->requestArray[i]->expectedFileSize) = input->filesizes[i]; totalsize += input->filesizes[i]; // compute total size to determine best space token } req.transferParameters->accessPattern = NULL; req.transferParameters->connectionType = NULL; req.transferParameters->arrayOfClientNetworks = NULL; req.transferParameters->arrayOfTransferProtocols = NULL; ret = srm_set_protocol_in_transferParameters(context,soap, req.transferParameters,input->protocols); if (ret) { srm_soap_free(soap); return (-1); } if (!input->spacetokendesc) { req.targetSpaceToken = NULL; } else { spacetokeninput.neededsize = totalsize; spacetokeninput.spacetokendesc = input->spacetokendesc; targetspacetoken = srm_getbestspacetoken (context,&spacetokeninput); if (targetspacetoken != NULL) { req.targetSpaceToken = targetspacetoken; } else { srm_soap_free(soap); return (-1); } } // Create sub-directories of SURLs - NOT NEEDED for srmv2.2 /*for (i = 0; i < input->nbfiles; ++i) { const char* dir = srm_strip_string(input->surls[i], '/'); int res = 0; assert (dir); if (dir && strlen(dir) > 0) { mkdirinput.dir_name = dir; res = srmv2_mkdir (context,mkdirinput); } free(dir); if (res < 0) { srm_soap_deinit(&soap); return (-1); } }*/ do { ret = call_function.call_srm2__srmPrepareToPut (soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmPrepareToPutResponse== NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmPrepareToPutResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_put_estimated_wait_time(&rep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); repfs = rep.srmPrepareToPutResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_QUEUED: if (copy_string(&output->token,rep.srmPrepareToPutResponse->requestToken)) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; } break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray || internal_context->current_status == srm_call_status_FAILURE) { internal_context->current_status = srm_call_status_FAILURE; if (internal_context->current_status == srm_call_status_FAILURE) { errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; } else { srm_call_err(context, NULL, srmfunc); errno = ECOMM; } }else{ if ( output->token == NULL && copy_string(&output->token,rep.srmPrepareToPutResponse->requestToken)) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else{ errno = 0; internal_context->current_status = srm_call_status_SUCCESS; ret = copy_pinfilestatuses_put(output->retstatus, &output->filestatuses, repfs, srmfunc); } } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_get_estimated_wait_time(struct srm2__srmPrepareToGetResponse_ *prepareTogetResp){ if(prepareTogetResp && prepareTogetResp->srmPrepareToGetResponse && prepareTogetResp->srmPrepareToGetResponse->arrayOfFileStatuses && prepareTogetResp->srmPrepareToGetResponse->arrayOfFileStatuses->statusArray > 0 && prepareTogetResp->srmPrepareToGetResponse->arrayOfFileStatuses->statusArray){ struct srm2__TGetRequestFileStatus* status= *prepareTogetResp->srmPrepareToGetResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime ){ return *status->estimatedWaitTime ; } } return -1; } int srmv2_prepare_to_get_async_internal(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output, struct srm_internal_context *internal_context) { char *targetspacetoken; int i; int ret = 0; struct srm2__srmPrepareToGetResponse_ rep; struct srm2__ArrayOfTGetRequestFileStatus *repfs; struct srm2__srmPrepareToGetRequest req; struct srm_getbestspacetokens_input spacetokeninput; struct soap* soap = srm_soap_init_context_new(context); static enum srm2__TFileStorageType s_types[] = {VOLATILE, DURABLE, PERMANENT}; const char srmfunc[] = "PrepareToGet"; /* issue "get" request */ memset (&req, 0, sizeof(req)); memset(output,0,sizeof(*output)); if ((req.arrayOfFileRequests = soap_malloc (soap, sizeof(struct srm2__ArrayOfTGetFileRequest))) == NULL || (req.arrayOfFileRequests->requestArray = soap_malloc (soap, input->nbfiles * sizeof(struct srm2__TGetFileRequest *))) == NULL || (req.transferParameters = soap_malloc (soap, sizeof(struct srm2__TTransferParameters))) == NULL || (req.targetSpaceToken = soap_malloc (soap, sizeof(char *))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } /* get first space token from user space token description */ if (!input->spacetokendesc) { req.targetSpaceToken = NULL; } else { spacetokeninput.spacetokendesc = input->spacetokendesc; targetspacetoken = srm_getbestspacetoken (context,&spacetokeninput); if (targetspacetoken != NULL) { req.targetSpaceToken = targetspacetoken; } else { srm_soap_free(soap); return (-1); } } if(context->ext && context->ext->turl_timeout){ // advanced context -> turl timeout req.desiredPinLifeTime = &(context->ext->turl_timeout); req.desiredTotalRequestTime = &(context->ext->turl_timeout); }else{ if (input->desiredpintime > 0) req.desiredPinLifeTime = &input->desiredpintime; else req.desiredPinLifeTime = &context->timeout; if (context->timeout_ops > 0) req.desiredTotalRequestTime = &context->timeout_ops; } req.desiredFileStorageType = &s_types[PERMANENT]; req.arrayOfFileRequests->__sizerequestArray = input->nbfiles; for (i = 0; i < input->nbfiles; i++) { if ((req.arrayOfFileRequests->requestArray[i] = soap_malloc (soap, sizeof(struct srm2__TGetFileRequest))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } memset (req.arrayOfFileRequests->requestArray[i], 0, sizeof(struct srm2__TGetFileRequest)); req.arrayOfFileRequests->requestArray[i]->sourceSURL = (char *)input->surls[i]; req.arrayOfFileRequests->requestArray[i]->dirOption = NULL; } req.transferParameters->accessPattern = NULL; req.transferParameters->connectionType = NULL; req.transferParameters->arrayOfClientNetworks = NULL; ret = srm_set_protocol_in_transferParameters(context,soap, req.transferParameters,input->protocols); if (ret) { srm_soap_free(soap); return (-1); } do { ret = call_function.call_srm2__srmPrepareToGet (soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmPrepareToGetResponse== NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmPrepareToGetResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_get_estimated_wait_time(&rep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); repfs = rep.srmPrepareToGetResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_QUEUED: if (copy_string(&output->token,rep.srmPrepareToGetResponse->requestToken)) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { break; }else { errno = 0; ret = copy_pinfilestatuses_get(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { errno = 0; internal_context->current_status = srm_call_status_SUCCESS; if(rep.srmPrepareToGetResponse->requestToken != NULL){ copy_string(&output->token,rep.srmPrepareToGetResponse->requestToken); } ret = copy_pinfilestatuses_get(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_get_status_estimated_wait_time(struct srm2__srmStatusOfGetRequestResponse_ *prepareTogetRespstatus){ if(prepareTogetRespstatus && prepareTogetRespstatus->srmStatusOfGetRequestResponse && prepareTogetRespstatus->srmStatusOfGetRequestResponse->arrayOfFileStatuses && prepareTogetRespstatus->srmStatusOfGetRequestResponse->arrayOfFileStatuses->__sizestatusArray > 0 && prepareTogetRespstatus->srmStatusOfGetRequestResponse->arrayOfFileStatuses->statusArray){ struct srm2__TGetRequestFileStatus* status = *prepareTogetRespstatus->srmStatusOfGetRequestResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime) return *status->estimatedWaitTime; } return -1; } int srmv2_status_of_get_request_async_internal(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output, struct srm_internal_context *internal_context) { struct srm2__ArrayOfTGetRequestFileStatus *repfs; int ret = 0; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmStatusOfGetRequestResponse_ srep; struct srm2__srmStatusOfGetRequestRequest sreq; const char srmfunc[] = "StatusOfGetRequest"; memset (&sreq, 0, sizeof(sreq)); sreq.requestToken = output->token; output->retstatus = NULL; output->filestatuses = NULL; do { ret = call_function.call_srm2__srmStatusOfGetRequest(soap, context->srm_endpoint, srmfunc, &sreq, &srep); // If no response break with failure if ((srep.srmStatusOfGetRequestResponse == NULL)||(ret!=0) || copy_returnstatus(&output->retstatus,srep.srmStatusOfGetRequestResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_get_status_estimated_wait_time(&srep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); repfs = srep.srmStatusOfGetRequestResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_QUEUED: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { break; }else { errno = 0; ret = copy_pinfilestatuses_get(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { errno = 0; internal_context->current_status = srm_call_status_SUCCESS; ret = copy_pinfilestatuses_get(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_put_done(struct srm_context *context, struct srm_putdone_input *input, struct srmv2_filestatus **statuses) { struct srm_internal_context internal_context; int ret=0; struct srm2__srmPutDoneResponse_ rep; struct srm2__TReturnStatus *reqstatp; struct srm2__ArrayOfTSURLReturnStatus *repfs; struct srm2__srmPutDoneRequest req; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "PutDone"; // Setup the timeout back_off_logic_init(context,&internal_context); memset (&req, 0, sizeof(req)); req.requestToken = (char *) input->reqtoken; // NOTE: only one SURL in the array if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **) input->surls; do { ret = call_function.call_srm2__srmPutDone(soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmPutDoneResponse == NULL)||(ret!=0)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context.current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) reqstatp = rep.srmPutDoneResponse->returnStatus; internal_context.current_status = back_off_logic(context,srmfunc,&internal_context,reqstatp); repfs = rep.srmPutDoneResponse->arrayOfFileStatuses; }while (internal_context.current_status == srm_call_status_INTERNAL_ERROR); switch(internal_context.current_status){ case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,reqstatp,srmfunc); srm_soap_free(soap); return (-1); }else { errno = 0; internal_context.current_status = srm_call_status_SUCCESS; ret = copy_filestatuses(reqstatp,statuses,repfs,srmfunc); } break; } srm_soap_free(soap); return (ret); } int srmv2_release_files(struct srm_context *context, struct srm_releasefiles_input *input, struct srmv2_filestatus **statuses) { struct srm_internal_context internal_context; int ret; struct srm2__srmReleaseFilesResponse_ rep; struct srm2__ArrayOfTSURLReturnStatus *repfs; struct srm2__srmReleaseFilesRequest req; struct srm2__TReturnStatus *reqstatp; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "ReleaseFiles"; // Setup the timeout back_off_logic_init(context,&internal_context); memset (&req, 0, sizeof(req)); req.requestToken = (char *) input->reqtoken; // NOTE: only one SURL in the array if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **) input->surls; do { ret = call_function.call_srm2__srmReleaseFiles(soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmReleaseFilesResponse == NULL)||(ret!=0)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context.current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Copy response status //internal_context.retstatus = rep.srmReleaseFilesResponse->returnStatus; // Check status and wait with back off logic if necessary(Internal_error) reqstatp = rep.srmReleaseFilesResponse->returnStatus; internal_context.current_status = back_off_logic(context,srmfunc,&internal_context,reqstatp); repfs = rep.srmReleaseFilesResponse->arrayOfFileStatuses; }while (internal_context.current_status == srm_call_status_INTERNAL_ERROR); switch(internal_context.current_status){ case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,reqstatp,srmfunc); srm_soap_free(soap); return (-1); }else { errno = 0; internal_context.current_status = srm_call_status_SUCCESS; ret = copy_filestatuses(reqstatp,statuses,repfs,srmfunc); } break; } srm_soap_free(soap); return (ret); } int srmv2_bringonline_estimated_wait_time(struct srm2__srmBringOnlineResponse_ *bringOnlineRep){ if( bringOnlineRep && bringOnlineRep->srmBringOnlineResponse && bringOnlineRep->srmBringOnlineResponse->arrayOfFileStatuses && bringOnlineRep->srmBringOnlineResponse->arrayOfFileStatuses->__sizestatusArray > 0 && bringOnlineRep->srmBringOnlineResponse->arrayOfFileStatuses->statusArray){ struct srm2__TBringOnlineRequestFileStatus* status = *bringOnlineRep->srmBringOnlineResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime){ return *status->estimatedWaitTime; } } return -1; } int srmv2_bring_online_async_internal (struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output, struct srm_internal_context *internal_context) { int ret,i; struct srm_getbestspacetokens_input spacetokeninput; struct srm2__srmBringOnlineResponse_ rep; struct srm2__ArrayOfTBringOnlineRequestFileStatus *repfs; struct srm2__srmBringOnlineRequest req; struct soap* soap = srm_soap_init_context_new(context); static enum srm2__TFileStorageType s_types[] = {VOLATILE, DURABLE, PERMANENT}; char *targetspacetoken; const char srmfunc[] = "BringOnline"; // issue "bringonline" request memset(output,0,sizeof(*output)); memset (&req, 0, sizeof(req)); if ((req.arrayOfFileRequests = soap_malloc (soap, sizeof(struct srm2__ArrayOfTGetFileRequest))) == NULL || (req.arrayOfFileRequests->requestArray = soap_malloc (soap, input->nbfiles * sizeof(struct srm2__TGetFileRequest *))) == NULL || (req.transferParameters = soap_malloc (soap, sizeof(struct srm2__TTransferParameters))) == NULL || (req.targetSpaceToken = soap_malloc (soap, sizeof(char *))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } // get first space token from user space token description if (!input->spacetokendesc) { req.targetSpaceToken = NULL; } else { spacetokeninput.spacetokendesc = input->spacetokendesc; targetspacetoken = srm_getbestspacetoken (context,&spacetokeninput); if (targetspacetoken != NULL) { req.targetSpaceToken = targetspacetoken; } else { srm_soap_free(soap); return (-1); } } req.authorizationID = NULL; req.userRequestDescription = NULL; req.storageSystemInfo = NULL; req.desiredFileStorageType = &s_types[PERMANENT]; req.targetFileRetentionPolicyInfo = NULL; req.deferredStartTime = NULL; req.arrayOfFileRequests->__sizerequestArray = input->nbfiles; for (i = 0; i < input->nbfiles; i++) { if ((req.arrayOfFileRequests->requestArray[i] = soap_malloc (soap, sizeof(struct srm2__TGetFileRequest))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } memset (req.arrayOfFileRequests->requestArray[i], 0, sizeof(struct srm2__TGetFileRequest)); req.arrayOfFileRequests->requestArray[i]->sourceSURL = (char *) input->surls[i]; req.arrayOfFileRequests->requestArray[i]->dirOption = NULL; } req.transferParameters->accessPattern = NULL; req.transferParameters->connectionType = NULL; req.transferParameters->arrayOfClientNetworks = NULL; ret = srm_set_protocol_in_transferParameters(context,soap, req.transferParameters,input->protocols); if (ret) { srm_soap_free(soap); return (-1); } do { ret = call_function.call_srm2__srmBringOnline (soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmBringOnlineResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmBringOnlineResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_bringonline_estimated_wait_time(&rep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus ); repfs = rep.srmBringOnlineResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_QUEUED: if (copy_string(&output->token,rep.srmBringOnlineResponse->requestToken)) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { break; }else { errno = 0; ret = copy_pinfilestatuses_bringonline(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { errno = 0; internal_context->current_status = srm_call_status_SUCCESS; ret = copy_pinfilestatuses_bringonline(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_bringonline_status_estimated_wait_time(struct srm2__srmStatusOfBringOnlineRequestResponse_ *bringOnlineStatusRep){ if( bringOnlineStatusRep && bringOnlineStatusRep->srmStatusOfBringOnlineRequestResponse && bringOnlineStatusRep->srmStatusOfBringOnlineRequestResponse->arrayOfFileStatuses && bringOnlineStatusRep->srmStatusOfBringOnlineRequestResponse->arrayOfFileStatuses->__sizestatusArray > 0 && bringOnlineStatusRep->srmStatusOfBringOnlineRequestResponse->arrayOfFileStatuses->statusArray){ struct srm2__TBringOnlineRequestFileStatus* status = *bringOnlineStatusRep->srmStatusOfBringOnlineRequestResponse->arrayOfFileStatuses->statusArray; if(status && status->estimatedWaitTime){ return *status->estimatedWaitTime; } } return -1; } int srmv2_status_of_bring_online_async_internal (struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output, struct srm_internal_context *internal_context) { int ret; struct srm2__ArrayOfTBringOnlineRequestFileStatus *repfs; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmStatusOfBringOnlineRequestResponse_ srep; struct srm2__srmStatusOfBringOnlineRequestRequest sreq; const char srmfunc[] = "StatusOfBringOnlineRequest"; memset (&sreq, 0, sizeof(sreq)); sreq.requestToken = (char *) output->token; output->retstatus = NULL; output->filestatuses = NULL; do { ret = call_function.call_srm2__srmStatusOfBringOnlineRequest(soap, context->srm_endpoint, srmfunc, &sreq, &srep); // If no response break with failure if ((srep.srmStatusOfBringOnlineRequestResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,srep.srmStatusOfBringOnlineRequestResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } set_estimated_wait_time(internal_context, srmv2_bringonline_status_estimated_wait_time(&srep)); // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); repfs = srep.srmStatusOfBringOnlineRequestResponse->arrayOfFileStatuses; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_SUCCESS: case srm_call_status_FAILURE: // Check if file structure ok if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { errno = 0; internal_context->current_status = srm_call_status_SUCCESS; ret = copy_pinfilestatuses_bringonline(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_QUEUED: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { break; }else { errno = 0; ret = copy_pinfilestatuses_bringonline(output->retstatus, &output->filestatuses, repfs, srmfunc); } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return (ret); } int srmv2_abort_files(struct srm_context *context, struct srm_abort_files_input *input,struct srmv2_filestatus **statuses) { int ret; struct srm_internal_context internal_context; struct srm2__srmAbortFilesResponse_ rep; struct srm2__ArrayOfTSURLReturnStatus *repfs; struct srm2__srmAbortFilesRequest req; struct srm2__TReturnStatus *reqstatp; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "AbortFiles"; // Setup the timeout back_off_logic_init(context,&internal_context); memset (&req, 0, sizeof(req)); req.requestToken = (char *) input->reqtoken; // NOTE: only one SURL in the array if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **) input->surls; do { ret = call_function.call_srm2__srmAbortFiles (soap, context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmAbortFilesResponse == NULL)||(ret!=0)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context.current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) reqstatp = rep.srmAbortFilesResponse->returnStatus; internal_context.current_status = back_off_logic(context,srmfunc,&internal_context,reqstatp); repfs = rep.srmAbortFilesResponse->arrayOfFileStatuses; }while (internal_context.current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context.current_status) { case srm_call_status_SUCCESS: case srm_call_status_FAILURE: if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,reqstatp,srmfunc); srm_soap_free(soap); return (-1); }else { errno = 0; internal_context.current_status = srm_call_status_SUCCESS; ret = copy_filestatuses(reqstatp,statuses,repfs,srmfunc); } break; case srm_call_status_TIMEOUT: // add timeout management for backoff logic errno = ETIMEDOUT; ret = -1; break; default: ret = -1; break; } srm_soap_free(soap); return (ret); } int srmv2_abort_request(struct srm_context *context,char *token) { const char srmfunc[] = "AbortRequest"; struct srm2__srmAbortRequestRequest abortreq; struct srm2__srmAbortRequestResponse_ abortrep; struct soap* soap = srm_soap_init_context_new(context); int result; memset (&abortreq, 0, sizeof(abortreq)); if (token == NULL) { // No token supplied errno = EINVAL; srm_soap_free(soap); return (-1); }else { abortreq.requestToken = token; result = call_function.call_srm2__srmAbortRequest (soap, context->srm_endpoint, srmfunc, &abortreq, &abortrep); if (result != 0) { // Soap call failure errno = srm_soap_call_err(context,soap,srmfunc); }else { if (abortrep.srmAbortRequestResponse == NULL || abortrep.srmAbortRequestResponse->returnStatus == NULL || abortrep.srmAbortRequestResponse->returnStatus->statusCode != SRM_USCORESUCCESS) { errno = EINVAL; srm_soap_free(soap); return (-1); } } } srm_soap_free(soap); return result; } srm-ifce-1.18.0/src/srm_struct_util.c0000644001662700052000000000611512217066060016500 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Devresse Adrien */ #include "srm_ifce_internal.h" srm_context_extension_t srm_context_extension_new(){ struct srm_context_extension* res = g_new0(struct srm_context_extension,1); res->polling_logic = SRM_POLLING_LOGIC_MIN_MAX_EXP; res->min_waittime.tv_nsec = 200000000; res->max_waittime.tv_sec = 5; res->turl_timeout = 3600; res->keep_alive = 0; return res; } void srm_context_extension_free(srm_context_extension_t context){ if(context){ g_free(context); } } // srm_context_t srm_context_new(const char * srm_endpoint, char *errbuf,int errbufsz,int verbose){ struct srm_context* context = g_new0(struct srm_context, 1); context->errbuf = errbuf; context->errbufsz = errbufsz; context->version = VERSION_2_2; context->srm_endpoint = g_strdup(srm_endpoint); context->timeout = 60; context->verbose = verbose; context->timeout_conn = srm_get_timeout_connect (); context->timeout_ops = srm_get_timeout_sendreceive(); context->ext = srm_context_extension_new(); context->ext->keep_alive = TRUE; return context; } srm_context_t srm_context_new2(const char * srm_endpoint, char *errbuf,int errbufsz,int verbose, int keep_alive){ srm_context_t c = srm_context_new(srm_endpoint, errbuf, errbufsz, verbose); c->ext->keep_alive = keep_alive; return c; } // void srm_context_free(srm_context_t context){ if(context){ if(context->ext){ // ext -> dynamically allocated g_free(context->srm_endpoint); srm_context_extension_free(context->ext); g_free(context); } } } // void srm_context_init(struct srm_context *context,char *srm_endpoint,char *errbuf,int errbufsz,int verbose) { GFAL_SRM_IFCE_ASSERT(context); context->ext = NULL; context->errbuf = errbuf; context->errbufsz = errbufsz; context->version = VERSION_2_2; context->srm_endpoint = srm_endpoint; context->timeout = 60; context->verbose = verbose; context->timeout_conn = srm_get_timeout_connect (); context->timeout_ops = srm_get_timeout_sendreceive(); } void srm_context_init2(struct srm_context *context,char *srm_endpoint,char *errbuf,int errbufsz,int verbose, int keep_alive){ srm_context_init(context, srm_endpoint, errbuf, errbufsz, verbose); context->ext = srm_context_extension_new(); context->ext->keep_alive = keep_alive; } srm-ifce-1.18.0/src/srmv2_data_transfer_functions.h0000644001662700052000000000501712217066060021301 0ustar adevresscg#pragma once #ifndef _SRMV2_DATA_TRANSFER_FUNCTIONS_ #define _SRMV2_DATA_TRANSFER_FUNCTIONS_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_status_of_put_request_async_internal(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output, struct srm_internal_context *internal_context); int srmv2_prepare_to_put_async_internal(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output, struct srm_internal_context *internal_context); int srmv2_prepare_to_get_async_internal(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output, struct srm_internal_context *internal_context); int srmv2_status_of_get_request_async_internal(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output, struct srm_internal_context *internal_context); int srmv2_status_of_bring_online_async_internal (struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output, struct srm_internal_context *internal_context); int srmv2_bring_online_async_internal (struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output, struct srm_internal_context *internal_context); int srmv2_release_files(struct srm_context *context, struct srm_releasefiles_input *input, struct srmv2_filestatus **statuses); int srmv2_put_done(struct srm_context *context, struct srm_putdone_input *input, struct srmv2_filestatus **statuses); int srmv2_abort_files(struct srm_context *context, struct srm_abort_files_input *input,struct srmv2_filestatus **statuses); int srmv2_abort_request(struct srm_context *context,char *token); #endif srm-ifce-1.18.0/src/typemap-srmv1.dat0000755001662700052000000000057112217066060016314 0ustar adevresscgsrm1 = "http://tempuri.org/diskCacheV111.srm.server.SRMServerV1" srmNs = "http://srm.1.0.ns" srmDiskCache = "http://www.themindelectric.com/package/diskCacheV111.srm/" srmWrappers = "http://www.themindelectric.com/wrappers/" srmJava = "http://www.themindelectric.com/package/java.lang/" srmPackage = "http://www.themindelectric.com/package/" xsd__dateTime = | char * | char * srm-ifce-1.18.0/src/srmv2_space_management_functions.c0000644001662700052000000003537712217066060021762 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include "srmv2_space_management_functions.h" int srmv2_getspacemd (struct srm_context *context, struct srm_getspacemd_input *input,struct srm_spacemd **spaces) { int i; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmGetSpaceMetaDataResponse_ tknrep; struct srm2__srmGetSpaceMetaDataRequest tknreq; struct srm2__TReturnStatus *tknrepstatp = NULL; struct srm2__ArrayOfTMetaDataSpace *tknrepp; const char srmfunc[] = "GetSpaceMetaData"; if (input->nbtokens < 1 || input->spacetokens == NULL || context->srm_endpoint == NULL || spaces == NULL) { srm_errmsg (context, "[SRM][srmv2_getspacemd][EINVAL] Invalid arguments"); errno = EINVAL; srm_soap_free(soap); return (-1); } if (input->spacetokens[input->nbtokens] != NULL) { srm_errmsg (context, "[SRM][srmv2_getspacemd][EINVAL] Invalid space token number"); errno = EINVAL; srm_soap_free(soap); return (-1); } memset (&tknreq, 0, sizeof(tknreq)); if ((tknreq.arrayOfSpaceTokens = soap_malloc (soap, input->nbtokens * sizeof(struct srm2__ArrayOfString))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } tknreq.arrayOfSpaceTokens->__sizestringArray = input->nbtokens; tknreq.arrayOfSpaceTokens->stringArray = input->spacetokens; if (call_function.call_srm2__srmGetSpaceMetaData(soap, context->srm_endpoint, srmfunc, &tknreq, &tknrep) != 0) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if (tknrep.srmGetSpaceMetaDataResponse == NULL || (tknrepstatp = tknrep.srmGetSpaceMetaDataResponse->returnStatus) == NULL) { errno = srm_call_err(context,tknrepstatp,srmfunc); srm_soap_free(soap); return (-1); } if (tknrepstatp->statusCode != SRM_USCORESUCCESS) { errno = srm_print_error_status(context,tknrepstatp,srmfunc); srm_soap_free(soap); return (-1); } tknrepp = tknrep.srmGetSpaceMetaDataResponse->arrayOfSpaceDetails; if (!tknrepp) { srm_errmsg (context, "[%s][%s][] %s: ", err_msg_begin,srmfunc, context->srm_endpoint); errno = ECOMM; srm_soap_free(soap); return (-1); } if (tknrepp->__sizespaceDataArray < 1 || !tknrepp->spaceDataArray) { srm_errmsg (context, "[%s][%s][] %s: no valid space tokens", err_msg_begin,srmfunc, context->srm_endpoint); srm_soap_free(soap); errno = EINVAL; return (-1); } if ((*spaces = (struct srm_spacemd *) calloc (input->nbtokens, sizeof (struct srm_spacemd))) == NULL) { srm_soap_free(soap); errno = ENOMEM; return (-1); } for (i = 0; i < input->nbtokens; i++) { if (!tknrepp->spaceDataArray[i] || !tknrepp->spaceDataArray[i]->spaceToken) continue; if (tknrepp->spaceDataArray[i]->status && tknrepp->spaceDataArray[i]->status->statusCode != SRM_USCORESUCCESS) { errno = srm_call_err(context,tknrepp->spaceDataArray[i]->status,srmfunc); srm_soap_free(soap); return (-1); } (*spaces)[i].spacetoken = strdup (tknrepp->spaceDataArray[i]->spaceToken); if (tknrepp->spaceDataArray[i]->owner) (*spaces)[i].owner = strdup (tknrepp->spaceDataArray[i]->owner); if (tknrepp->spaceDataArray[i]->totalSize) (*spaces)[i].totalsize = (SRM_LONG64) *(tknrepp->spaceDataArray[i]->totalSize); if (tknrepp->spaceDataArray[i]->guaranteedSize) (*spaces)[i].guaranteedsize = (SRM_LONG64) *(tknrepp->spaceDataArray[i]->guaranteedSize); if (tknrepp->spaceDataArray[i]->unusedSize) (*spaces)[i].unusedsize = (SRM_LONG64) *(tknrepp->spaceDataArray[i]->unusedSize); if (tknrepp->spaceDataArray[i]->lifetimeAssigned) (*spaces)[i].lifetimeassigned = *(tknrepp->spaceDataArray[i]->lifetimeAssigned); if (tknrepp->spaceDataArray[i]->lifetimeLeft) (*spaces)[i].lifetimeleft = *(tknrepp->spaceDataArray[i]->lifetimeLeft); if (tknrepp->spaceDataArray[i]->retentionPolicyInfo) { switch (tknrepp->spaceDataArray[i]->retentionPolicyInfo->retentionPolicy) { case REPLICA: (*spaces)[i].retentionpolicy = GFAL_POLICY_REPLICA; break; case OUTPUT: (*spaces)[i].retentionpolicy = GFAL_POLICY_OUTPUT; break; case CUSTODIAL: (*spaces)[i].retentionpolicy = GFAL_POLICY_CUSTODIAL; break; default: (*spaces)[i].retentionpolicy = GFAL_POLICY_UNKNOWN; } if (tknrepp->spaceDataArray[i]->retentionPolicyInfo->accessLatency) { switch (*(tknrepp->spaceDataArray[i]->retentionPolicyInfo->accessLatency)) { case ONLINE: (*spaces)[i].accesslatency = GFAL_LATENCY_ONLINE; break; case NEARLINE: (*spaces)[i].accesslatency = GFAL_LATENCY_NEARLINE; break; default: (*spaces)[i].accesslatency = GFAL_LATENCY_UNKNOWN; } } } } srm_soap_free(soap); errno = 0; return (0); } // returns space tokens associated to the space description int srmv2_getspacetokens (struct srm_context *context, struct srm_getspacetokens_input *input, struct srm_getspacetokens_output *output) { int i; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmGetSpaceTokensResponse_ tknrep; struct srm2__srmGetSpaceTokensRequest tknreq; struct srm2__TReturnStatus *tknrepstatp = NULL; struct srm2__ArrayOfString *tknrepp; const char srmfunc[] = "GetSpaceTokens"; if (input == NULL || input->spacetokendesc == NULL || context->srm_endpoint == NULL || output == NULL) { srm_errmsg( context, "[SRM][srmv2_getspacetokens][EINVAL] Invalid arguments"); errno = EINVAL; return (-1); } memset(output,0,sizeof(*output)); memset (&tknreq, 0, sizeof(tknreq)); tknreq.userSpaceTokenDescription = (char *) input->spacetokendesc; if (call_function.call_srm2__srmGetSpaceTokens (soap, context->srm_endpoint, srmfunc, &tknreq, &tknrep) != 0) { srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if (tknrep.srmGetSpaceTokensResponse == NULL || (tknrepstatp = tknrep.srmGetSpaceTokensResponse->returnStatus) == NULL) { errno = srm_call_err(context,tknrepstatp,srmfunc); srm_soap_free(soap); return (-1); } if (tknrepstatp->statusCode != SRM_USCORESUCCESS) { errno = srm_print_error_status(context,tknrepstatp,srmfunc);; srm_soap_free(soap); return (-1); } tknrepp = tknrep.srmGetSpaceTokensResponse->arrayOfSpaceTokens; if (!tknrepp) { srm_errmsg (context, "[SE][%s][%s] %s: ", srmfunc, statuscode2errmsg (tknrepstatp->statusCode), context->srm_endpoint); srm_soap_free(soap); errno = ECOMM; return (-1); } output->nbtokens = tknrepp->__sizestringArray; if (output->nbtokens < 1 || !tknrepp->stringArray) { srm_errmsg (context, "[%s][%s][%s] %s: %s: No such space token descriptor", err_msg_begin,srmfunc, statuscode2errmsg (tknrepstatp->statusCode), context->srm_endpoint,input->spacetokendesc); srm_soap_free(soap); errno = EINVAL; return (-1); } if ((output->spacetokens = (char **) calloc (output->nbtokens + 1, sizeof (char *))) == NULL) { srm_soap_free(soap); errno = ENOMEM; return (-1); } for (i = 0; i < output->nbtokens; ++i) output->spacetokens[i] = strdup(tknrepp->stringArray[i]); srm_soap_free(soap); errno = 0; return (0); } // returns best space token char* srmv2_getbestspacetoken (struct srm_context *context, struct srm_getbestspacetokens_input *input) { struct srm_getspacetokens_input getspacetoken_input; struct srm_getspacetokens_output getspacetoken_output; struct srm_getspacemd_input getspacemd_input;; int sav_errno = 0; int i, ret, numtoken = -1; SRM_LONG64 unusedsize = -1; char **spacetokens = NULL; struct srm_spacemd *spacemd = NULL; char *spacetoken = NULL; getspacetoken_input.spacetokendesc = input->spacetokendesc; ret = srmv2_getspacetokens(context,&getspacetoken_input,&getspacetoken_output); if (ret < 0 || getspacetoken_output.spacetokens == NULL || getspacetoken_output.nbtokens < 1) { errno = ret == 0 ? ENOMEM : errno; return (NULL); } if (getspacetoken_output.nbtokens == 1) { errno = 0; spacetoken = getspacetoken_output.spacetokens[0]; free (getspacetoken_output.spacetokens); return (spacetoken); } getspacemd_input.nbtokens = getspacetoken_output.nbtokens; getspacemd_input.spacetokens = getspacetoken_output.spacetokens; ret = srmv2_getspacemd (context,&getspacemd_input,&spacemd); if (ret < 0 || spacemd == NULL) { sav_errno = ret == 0 ? ENOMEM : errno; for (i = 0; i < getspacetoken_output.nbtokens; ++i) if (getspacetoken_output.spacetokens[i]) free (getspacetoken_output.spacetokens[i]); free (getspacetoken_output.spacetokens); errno = sav_errno; srm_spacemd_free (getspacetoken_output.nbtokens, spacemd); return (NULL); } // Get the spacetoken with the least free space, but a bit more than needed for (i = 0; i < getspacetoken_output.nbtokens; ++i) { if (getspacetoken_output.spacetokens[i]) free (getspacetoken_output.spacetokens[i]); if (spacemd[i].unusedsize < input->neededsize + SRM_SIZE_MARGIN) continue; if (numtoken < 0 || spacemd[i].unusedsize < unusedsize) { numtoken = i; unusedsize = spacemd[i].unusedsize; } } if (numtoken < 0) { // no suitable space token srm_errmsg (context,"[SRM][srmv2_getbestspacetoken][EINVAL] %s: no associated space token with enough free space", input->spacetokendesc); errno = EINVAL; srm_spacemd_free (getspacetoken_output.nbtokens, spacemd); return (NULL); } spacetoken = spacemd[numtoken].spacetoken; spacemd[numtoken].spacetoken = NULL; // prevent it to be freed srm_spacemd_free (getspacetoken_output.nbtokens, spacemd); free (spacetokens); errno = 0; return (spacetoken); } // returns space tokens associated to the space description int srmv2_reservespace(struct srm_context *context, struct srm_reservespace_input *input, struct srm_reservespace_output *output) { struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmReserveSpaceResponse_ rep; struct srm2__srmReserveSpaceRequest req; struct srm2__TRetentionPolicyInfo retentionPolicy; const char srmfunc[] = "ReserveSpace"; if (input->spacetokendescriptor == NULL) { srm_errmsg( context, "[SRM][%s][EINVAL] Invalid arguments",srmfunc); errno = EINVAL; return (-1); } memset(output,0,sizeof(*output)); memset (&req, 0, sizeof(req)); req.userSpaceTokenDescription = input->spacetokendescriptor; req.desiredSizeOfTotalSpace = NULL; req.desiredSizeOfGuaranteedSpace = input->desired_size; retentionPolicy.accessLatency = NULL; retentionPolicy.retentionPolicy = 0; req.retentionPolicyInfo = &retentionPolicy; req.desiredLifetimeOfReservedSpace = &input->desired_lifetime; if (call_function.call_srm2__srmReserveSpace(soap, context->srm_endpoint, srmfunc, &req, &rep) != 0) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if (copy_string(&output->spacetoken,rep.srmReserveSpaceResponse->spaceToken)) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if (output->spacetoken != NULL) { //printf("Reserved Space token: %s \n",output->spacetoken); } srm_soap_free(soap); errno = 0; return (0); } int srmv2_releasespace(struct srm_context *context, char *spacetoken) { struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmReleaseSpaceResponse_ rep; struct srm2__srmReleaseSpaceRequest req; const char srmfunc[] = "ReserveSpace"; if (spacetoken == NULL) { srm_errmsg( context, "[SRM][%s][EINVAL] Invalid arguments",srmfunc); errno = EINVAL; return (-1); } memset (&req, 0, sizeof(req)); req.spaceToken = spacetoken; if (call_function.call_srm2__srmReleaseSpace(soap, context->srm_endpoint, srmfunc, &req, &rep) != 0) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } srm_soap_free(soap); errno = 0; return (0); } // returns space tokens associated to the space description int srmv2_purgefromspace(struct srm_context *context, struct srm_purgefromspace_input *input, struct srm_purgefromspace_output *output) { int n,i,ret; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmPurgeFromSpaceResponse_ rep; struct srm2__srmPurgeFromSpaceRequest req; struct srm2__ArrayOfTSURLReturnStatus *repfs; const char srmfunc[] = "PurgeFromSpace"; if (input->spacetoken == NULL) { srm_errmsg( context, "[SRM][%s][EINVAL] Invalid arguments",srmfunc); errno = EINVAL; return (-1); } memset(output,0,sizeof(*output)); memset (&req, 0, sizeof(req)); if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **)input->surls; req.spaceToken = input->spacetoken; if ((ret = call_function.call_srm2__srmPurgeFromSpace(soap, context->srm_endpoint, srmfunc, &req, &rep))) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if ((rep.srmPurgeFromSpaceResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmPurgeFromSpaceResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return -1; } repfs = rep.srmPurgeFromSpaceResponse->arrayOfFileStatuses; if (output->retstatus->statusCode != SRM_USCORESUCCESS || !repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,output->retstatus,srmfunc); srm_soap_free(soap); return (-1); } n = repfs->__sizestatusArray; if ((output->statuses = (struct srmv2_filestatus*) calloc (n, sizeof (struct srmv2_filestatus))) == NULL) { errno = ENOMEM; srm_soap_free(soap); return (-1); } for (i = 0; i < n; ++i) { if (!repfs->statusArray[i]) continue; if (repfs->statusArray[i]->surl) (output->statuses)[i].surl = strdup (repfs->statusArray[i]->surl); if (repfs->statusArray[i]->status) { (output->statuses)[i].status = statuscode2errno(repfs->statusArray[i]->status->statusCode); srm_print_explanation(&((output->statuses)[i].explanation), repfs->statusArray[i]->status,srmfunc); } } srm_soap_free(soap); errno = 0; return (n); } srm-ifce-1.18.0/src/srm.v2.2.wsdl0000644001662700052000000030631712217066060015263 0ustar adevresscg srm.v2.2.wsdl Wed Sep 27 08:22:41 PDT 2006 Mon Jul 3 09:49:53 PDT 2006 Tue Jun 20 07:21:54 PDT 2006 - FINALIZED Mon Jun 19 09:45:38 PDT 2006 Created by Junmin Gu, Alex Sim Lawrence Berkeley National Laboratory on basis of the Storage Resource Manager Interface Specification v2.2 published at http://sdm.lbl.gov/srm-wg the following location of the service is specific to the particular deployment and is not part of the specification srm-ifce-1.18.0/src/srmv2_directory_functions.c0000644001662700052000000004737412217066060020477 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include #include "srm_ifce_internal.h" #include "srm_soap.h" // Utility functions int srmv2_check_srm_root(const char* surl); int srmv2_rm(struct srm_context *context,struct srm_rm_input *input,struct srm_rm_output *output); int srmv2_rmdir(struct srm_context *context,struct srm_rmdir_input *input,struct srm_rmdir_output *output); int srmv2_mkdir(struct srm_context *context,struct srm_mkdir_input *input); // Asynchronous srm ls call void srm_ls_output_destroy(struct srm_ls_output *output) { if (output == NULL) { return; } srm_srm2__TReturnStatus_delete(output->retstatus); output->retstatus = NULL; free(output->token); output->token = NULL; srm_srmv2_mdfilestatus_delete(output->statuses, output->statuses_num); output->statuses = NULL; } int srmv2_ls_async_internal(struct srm_context *context, struct srm_ls_input *input,struct srm_ls_output *output,struct srm_internal_context *internal_context) { int ret; enum xsd__boolean trueoption = true_; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "Ls"; struct srm2__srmLsRequest req; struct srm2__srmLsResponse_ rep; struct srm2__ArrayOfTMetaDataPathDetail *repfs = NULL; /* Basic sanity checks */ if (input->offset && *input->offset < 0) { errno = EINVAL; srm_errmsg (context, "[SRM][srmv2_ls_async_internal][] Negative offset value is illegal."); return -1; } if (input->count < 0) { errno = EINVAL; srm_errmsg (context, "[SRM][srmv2_ls_async_internal][] Negative count value is illegal."); return -1; } memset(output,0,sizeof(*output)); memset (&req, 0, sizeof(req)); if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.fullDetailedList = &trueoption; req.numOfLevels = &(input->numlevels); if (input->offset && *input->offset > 0) { req.offset = input->offset; } if (input->count > 0) { req.count = &(input->count); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **)input->surls; do { // Gsoap call soap_call_srm2__srmLs ret = call_function.call_srm2__srmLs(soap,context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmLsResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmLsResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus); }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); switch (internal_context->current_status) { case srm_call_status_QUEUED: if (copy_string(&output->token,rep.srmLsResponse->requestToken)) { internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } break; case srm_call_status_SUCCESS: case srm_call_status_FAILURE: // Copy file structure to another pointer for easier manipulation repfs = rep.srmLsResponse->details; // Check if file structure ok if (!repfs || repfs->__sizepathDetailArray <= 0 || !repfs->pathDetailArray) { // file list empty error internal_context->current_status = srm_call_status_FAILURE; errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; }else { internal_context->current_status = srm_call_status_SUCCESS; // Everything is fine copy file structure and check if copy went ok ret = copy_mdfilestatuses(output->retstatus, &output->statuses,repfs); if (ret == -1) { errno = srm_call_err(context,output->retstatus,srmfunc); internal_context->current_status = srm_call_status_FAILURE; }else { output->statuses_num = repfs->__sizepathDetailArray; if (ret == 1 && input->offset && output->retstatus->statusCode == SRM_USCORETOO_USCOREMANY_USCORERESULTS && repfs->pathDetailArray[0] != NULL && repfs->pathDetailArray[0]->arrayOfSubPaths != NULL) { // offset is only supported for a single directory listing *input->offset += repfs->pathDetailArray[0]->arrayOfSubPaths->__sizepathDetailArray; }else if (input->offset) { *input->offset = 0; } } } break; case srm_call_status_TIMEOUT: errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return ret; } int srmv2_status_of_ls_request_async_internal(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output, struct srm_internal_context *internal_context) { const char srmfunc[] = "StatusOfLsRequest"; struct soap* soap = srm_soap_init_context_new(context); struct srm2__srmStatusOfLsRequestResponse_ srep; struct srm2__srmStatusOfLsRequestRequest sreq; struct srm2__ArrayOfTMetaDataPathDetail *repfs = NULL; int ret; // wait for files ready memset (&sreq, 0, sizeof(sreq)); sreq.requestToken = output->token; output->retstatus = NULL; output->statuses = NULL; internal_context->current_status = srm_call_status_FAILURE; do { ret = call_function.call_srm2__srmStatusOfLsRequest (soap, context->srm_endpoint, srmfunc, &sreq, &srep); // If no response break with failure if ((srep.srmStatusOfLsRequestResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,srep.srmStatusOfLsRequestResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context->current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) internal_context->current_status = back_off_logic(context,srmfunc,internal_context,output->retstatus ); repfs = srep.srmStatusOfLsRequestResponse->details; }while (internal_context->current_status == srm_call_status_INTERNAL_ERROR); // If success switch (internal_context->current_status) { case srm_call_status_SUCCESS: case srm_call_status_FAILURE: // Check if file structure ok if (!repfs || repfs->__sizepathDetailArray <= 0 || !repfs->pathDetailArray) { // file list empty error errno = srm_call_err(context,output->retstatus,srmfunc); internal_context->current_status = srm_call_status_FAILURE; ret = -1; }else { internal_context->current_status = srm_call_status_SUCCESS; // Everything is fine copy file structure and check if copy went ok ret = copy_mdfilestatuses(output->retstatus, &output->statuses,repfs ); if (ret == -1) { errno = srm_call_err(context,output->retstatus,srmfunc); internal_context->current_status = srm_call_status_FAILURE; }else { output->statuses_num = repfs->__sizepathDetailArray; if (ret == 1 && input->offset && output->retstatus->statusCode == SRM_USCORETOO_USCOREMANY_USCORERESULTS && repfs->pathDetailArray[0] != NULL && repfs->pathDetailArray[0]->arrayOfSubPaths != NULL) { // offset is only supported for a single directory listing *input->offset += repfs->pathDetailArray[0]->arrayOfSubPaths->__sizepathDetailArray; }else if (input->offset) { *input->offset = 0; } } } break; case srm_call_status_QUEUED: break; case srm_call_status_TIMEOUT: errno = ETIMEDOUT; ret = -1; break; default: errno = srm_call_err(context,output->retstatus,srmfunc); ret = -1; break; } srm_soap_free(soap); return (ret); } int srmv2_rm(struct srm_context *context,struct srm_rm_input *input,struct srm_rm_output *output) { struct srm2__srmRmResponse_ rep; struct srm2__ArrayOfTSURLReturnStatus *repfs; struct srm2__srmRmRequest req; //struct srm2__TReturnStatus *reqstatp; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "srmRm"; struct srm_internal_context internal_context; int i,n,ret; back_off_logic_init(context,&internal_context); memset (&req, 0, sizeof(req)); memset(output,0,sizeof(*output)); // NOTE: only one file in the array if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = (char **) input->surls; // issue "srmRm" request do { // Gsoap call ret = call_function.call_srm2__srmRm (soap,context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmRmResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmRmResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context.current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) internal_context.current_status = back_off_logic(context,srmfunc,&internal_context,output->retstatus); }while (internal_context.current_status == srm_call_status_INTERNAL_ERROR); if(internal_context.current_status == srm_call_status_TIMEOUT){ errno = ETIMEDOUT; srm_soap_free(soap); return (-1); } repfs = rep.srmRmResponse->arrayOfFileStatuses; if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,output->retstatus,srmfunc); srm_soap_free(soap); return (-1); } n = repfs->__sizestatusArray; if ((output->statuses = (struct srmv2_filestatus*) calloc (n, sizeof (struct srmv2_filestatus))) == NULL) { errno = ENOMEM; srm_soap_free(soap); return (-1); } for (i = 0; i < n; ++i) { if (!repfs->statusArray[i]) continue; if (repfs->statusArray[i]->surl) (output->statuses)[i].surl = strdup (repfs->statusArray[i]->surl); if (repfs->statusArray[i]->status) { (output->statuses)[i].status = statuscode2errno(repfs->statusArray[i]->status->statusCode); srm_print_explanation(&((output->statuses)[i].explanation), repfs->statusArray[i]->status,srmfunc); } } srm_soap_free(soap); errno = 0; return (n); } //srmv2_rmdir (const char *surl, const char *srm_endpoint, int recursive, //struct srmv2_filestatus **statuses, char *errbuf, int errbufsz, int timeout) int srmv2_rmdir(struct srm_context *context,struct srm_rmdir_input *input,struct srm_rmdir_output *output) { int ret; struct srm2__srmRmdirResponse_ rep; struct srm2__srmRmdirRequest req; enum xsd__boolean trueoption = true_; struct srm_internal_context internal_context; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "srmRmdir"; back_off_logic_init(context,&internal_context); memset (&req, 0, sizeof(req)); memset(output,0,sizeof(*output)); req.SURL = (char *) input->surl; if (input->recursive) { req.recursive = &trueoption; } // issue "srmRmdir" request do { // Gsoap call ret = call_function.call_srm2__srmRmdir(soap,context->srm_endpoint, srmfunc, &req, &rep); // If no response break with failure if ((rep.srmRmdirResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmRmdirResponse->returnStatus)) { errno = srm_soap_call_err(context,soap,srmfunc); internal_context.current_status = srm_call_status_FAILURE; srm_soap_free(soap); return -1; } // Check status and wait with back off logic if necessary(Internal_error) internal_context.current_status = back_off_logic(context,srmfunc,&internal_context,output->retstatus); }while (internal_context.current_status == srm_call_status_INTERNAL_ERROR); if(internal_context.current_status == srm_call_status_TIMEOUT){ errno = ETIMEDOUT; srm_soap_free(soap); return (-1); } if ((output->statuses = (struct srmv2_filestatus*) calloc (1, sizeof (struct srmv2_filestatus))) == NULL) { errno = ENOMEM; srm_soap_free(soap); return (-1); } output->statuses[0].surl = strdup (input->surl); output->statuses[0].status = statuscode2errno (output->retstatus->statusCode); if (output->statuses[0].status) { srm_print_explanation(&((output->statuses)[0].explanation),output->retstatus,srmfunc); } srm_soap_free(soap); errno = 0; return (1); //deleted one folder } /* tries to create all directories in 'dest_file' */ int srmv2_mkdir(struct srm_context *context,struct srm_mkdir_input *input) { char* file = NULL; int ret = -1; int sav_errno = 0; char *p, *endp; struct srm2__srmMkdirResponse_ rep; struct srm2__srmMkdirRequest req; struct srm2__TReturnStatus *repstatp; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "Mkdir"; memset (&req, 0, sizeof (struct srm2__srmMkdirRequest)); memset (&rep, 0, sizeof (struct srm2__srmMkdirResponse_)); file = srm_util_normalize_surl(input->dir_name); p = endp = strrchr (file, '/'); // 1st cycle, trying to create directories ascendingly, until success do { /* Do not try to create the root directory... */ if (srmv2_check_srm_root(file)) { break; } *p = 0; req.SURL = file; if (call_function.call_srm2__srmMkdir (soap, context->srm_endpoint, srmfunc, &req, &rep)) { errno = srm_soap_call_err(context,soap,srmfunc); goto CLEANUP_AND_RETURN; } repstatp = rep.srmMkdirResponse->returnStatus; sav_errno = statuscode2errno (repstatp->statusCode); if (sav_errno != 0 && sav_errno != EEXIST && sav_errno != ENOENT) { srm_print_error_status_additional(context,repstatp,srmfunc,input->dir_name); errno = sav_errno; goto CLEANUP_AND_RETURN; } } while (sav_errno == ENOENT && (p = strrchr (file, '/')) != NULL); if (p == NULL) { // should never happen, failure must appear in soap call srm_errmsg (context, "[SRM][srmv2_makedirp][EINVAL] %s: Invalid SURL", input->dir_name); errno = EINVAL; goto CLEANUP_AND_RETURN; } // 2nd cycle, creating directories descendingly as of the one created by previous cycle *p = '/'; sav_errno = 0; while (sav_errno == 0 && p < endp && (p = strchr (p + 1, 0)) != NULL) { req.SURL = file; if (call_function.call_srm2__srmMkdir(soap, context->srm_endpoint, srmfunc, &req, &rep)) { errno = srm_soap_call_err(context,soap,srmfunc); errno = ECOMM; goto CLEANUP_AND_RETURN; } repstatp = NULL; if (rep.srmMkdirResponse == NULL || (repstatp = rep.srmMkdirResponse->returnStatus) == NULL || statuscode2errno (repstatp->statusCode) != 0) { errno = srm_call_err(context,repstatp,srmfunc); goto CLEANUP_AND_RETURN; } *p = '/'; } errno = 0; ret = 0; CLEANUP_AND_RETURN: free(file); srm_soap_free(soap); return ret; } int srmv2_mv(struct srm_context *context, struct srm_mv_input *input) { struct srm2__srmMvRequest request; struct srm2__srmMvResponse_ response; struct soap *soap; const char srmfunc[] = "Mv"; int ret; request.authorizationID = NULL; request.fromSURL = input->from; request.toSURL = input->to; request.storageSystemInfo = NULL; memset(&response, 0, sizeof(response)); soap = srm_soap_init_context_new(context); ret = call_function.call_srm2__srmMv(soap, context->srm_endpoint, srmfunc, &request, &response); if (ret) { errno = srm_soap_call_err(context, soap, srmfunc); srm_soap_free(soap); return -1; } if (response.srmMvResponse->returnStatus == NULL || statuscode2errno(response.srmMvResponse->returnStatus->statusCode) != 0) { errno = srm_call_err(context, response.srmMvResponse->returnStatus, srmfunc); } srm_soap_free(soap); return (errno)?-1:0; } int srmv2_extend_file_lifetime(struct srm_context *context, struct srm_extendfilelifetime_input *input, struct srm_extendfilelifetime_output *output) { int ret; struct srm2__ArrayOfTSURLLifetimeReturnStatus *repfs; struct srm2__srmExtendFileLifeTimeResponse_ rep; struct srm2__srmExtendFileLifeTimeRequest req; struct soap* soap = srm_soap_init_context_new(context); const char srmfunc[] = "ExtendFileLifeTime"; /* issue "extendfilelifetime" request */ memset (&req, 0, sizeof(req)); memset(output,0,sizeof(*output)); if ((req.arrayOfSURLs = soap_malloc (soap, sizeof(struct srm2__ArrayOfAnyURI))) == NULL) { srm_errmsg (context, "[SRM][soap_malloc][] error"); errno = ENOMEM; srm_soap_free(soap); return (-1); } req.authorizationID = NULL; req.requestToken = input->reqtoken; req.newFileLifeTime = NULL; req.newPinLifeTime = &input->pintime; req.arrayOfSURLs->__sizeurlArray = input->nbfiles; req.arrayOfSURLs->urlArray = input->surls; if ((ret = call_function.call_srm2__srmExtendFileLifeTime (soap, context->srm_endpoint, srmfunc, &req, &rep))) { errno = srm_soap_call_err(context,soap,srmfunc); srm_soap_free(soap); return (-1); } if ((rep.srmExtendFileLifeTimeResponse == NULL)||(ret!=0)|| copy_returnstatus(&output->retstatus,rep.srmExtendFileLifeTimeResponse->returnStatus)) { errno = srm_call_err(context,output->retstatus,srmfunc); srm_soap_free(soap); return (-1); } /* return file statuses */ repfs = rep.srmExtendFileLifeTimeResponse->arrayOfFileStatuses; if (!repfs || repfs->__sizestatusArray < 1 || !repfs->statusArray) { errno = srm_call_err(context,output->retstatus,srmfunc); srm_soap_free(soap); return (-1); } errno = 0; ret = copy_pinfilestatuses_extendlifetime(output->retstatus, &output->filestatuses, repfs, srmfunc); srm_soap_free(soap); return (ret); } int srmv2_check_srm_root(const char* surl) { int ret = 0; static regex_t re; static int is_compiled = 0; static const char* regexp = "^srm://[^/]*/$"; #define SRMV1_CHECK_SRM_ROOT_NMATCH 1 regmatch_t match[SRMV1_CHECK_SRM_ROOT_NMATCH]; if (surl == NULL) { return 0; } if (!is_compiled) { int comp_res = regcomp(&re, regexp, REG_ICASE); assert(comp_res == 0); is_compiled = 1; } if (0 == regexec(&re, surl, SRMV1_CHECK_SRM_ROOT_NMATCH, match, 0)) { ret = 1; } return ret; #undef SRMV1_CHECK_SRM_ROOT_NMATCH } srm-ifce-1.18.0/src/srm_ifce_internal.h0000644001662700052000000000327112217066060016726 0ustar adevresscg#pragma once #ifndef SRM_IFCE_INTERNAL_H_ #define SRM_IFCE_INTERNAL_H_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Adrien Devresse, CERN */ #include #include #include #include "gfal_srm_ifce.h" #include "srm_dependencies.h" #include "srm_util.h" #include "srmv2_discovery_functions.h" #include "srmv2_permission_functions.h" #include "srmv2_data_transfer_functions.h" #include "srmv2_directory_functions.h" #include "srmv2_space_management_functions.h" typedef enum _srm_polling_logic{ SRM_POLLING_LOGIC_OLD, SRM_POLLING_LOGIC_MIN_MAX_EXP } srm_polling_logic; struct srm_context_extension{ // asynchronous query strategy srm_polling_logic polling_logic; // polling MIN_MAX_EXP params struct timespec min_waittime; struct timespec max_waittime; // advanced timeout management int turl_timeout; // keep alive connections int keep_alive; }; /* Normal assertion for srm-ifce */ #define GFAL_SRM_IFCE_ASSERT(cond) \ do{ \ g_assert((cond)); \ }while(0) #endif srm-ifce-1.18.0/src/gfal_srm_ifce_unittest_srmls.c0000644001662700052000000003746612217066060021212 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "gfal_srm_ifce_unittest.h" #include "srm_util.h" #include "srmv2_directory_functions.h" START_TEST (test_wait_for_new_attempt) { struct srm_internal_context internal_context; internal_context.estimated_wait_time = -1; internal_context.attempt = 11; fail_if (wait_for_new_attempt(&internal_context) != -1, "Wait for new attempt does not return timeout error for 11 attempts!"); internal_context.attempt = 5; internal_context.end_time = time(NULL)-1; fail_if (wait_for_new_attempt(&internal_context) != -1, "Timeout error not received!"); call_function.call_sleep = mock_sleep; internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; fail_if (wait_for_new_attempt(&internal_context) != 0, "Timeout should not occur!"); fail_if (mock_sleep_time > 1, // be careful changing this number "Random sleep time exceeded expected value !!!"); internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; internal_context.estimated_wait_time = 0; fail_if (wait_for_new_attempt(&internal_context) != -1, "Timeout should occur!"); internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; internal_context.estimated_wait_time = -10; fail_if (mock_sleep_time > 1, // be careful changing this number "Random sleep time exceeded expected value !!!"); internal_context.estimated_wait_time = 10; wait_for_new_attempt(&internal_context); fail_if (mock_sleep_time != 10, "Sleep time estimated wait time not equal to sleep time!"); } END_TEST int soap_call_srm2__srmLs_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { _param_18->srmLsResponse = NULL; return 0; // success but return statuses are null } int soap_call_srm2__srmLs_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->requestToken = NULL; resp->details = NULL; _param_18->srmLsResponse = resp; return -1; // failure } int soap_call_srm2__srmLs_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREPARTIAL_USCORESUCCESS; retstatus->explanation = NULL; resp->requestToken = NULL; resp->details = NULL; resp->returnStatus = retstatus; _param_18->srmLsResponse = resp; return 0; // success } int soap_call_srm2__srmLs_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->requestToken = NULL; resp->details = NULL; _param_18->srmLsResponse = resp; return 0; // success } int soap_call_srm2__srmLs_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->details = NULL; resp->requestToken = NULL; _param_18->srmLsResponse = resp; return 0; // success } int soap_call_srm2__srmLs_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->details = NULL; resp->requestToken = fixture_test_string; _param_18->srmLsResponse = resp; return 0; // success } int soap_call_srm2__srmLs_test7(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmLsRequest *srmLsRequest, struct srm2__srmLsResponse_ *_param_18) { struct srm2__srmLsResponse *resp = (struct srm2__srmLsResponse *) soap_malloc (soap,sizeof (struct srm2__srmLsResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmLsResponse = resp; resp->details = (struct srm2__ArrayOfTMetaDataPathDetail*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTMetaDataPathDetail)); resp->details->__sizepathDetailArray = 1; resp->details->pathDetailArray = (struct srm2__TMetaDataPathDetail **) soap_malloc (soap,sizeof (struct srm2__TMetaDataPathDetail *)); resp->details->pathDetailArray[0] = (struct srm2__TMetaDataPathDetail *) soap_malloc (soap,sizeof (struct srm2__TMetaDataPathDetail )); resp->details->pathDetailArray[0] = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_ls_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_ls_async) { struct srm_ls_output output; struct srm_context context; struct srm_internal_context internal_context; struct srm_ls_input input; char *test_surls_ls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function context.verbose = 0; context.errbuf = NULL; context.errbufsz = 0; context.srm_endpoint = "test"; input.offset = NULL; input.nbfiles = 1; input.count = 0; input.numlevels = 1; input.surls = test_surls_ls; input.offset = 0; call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test1; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 1!"); internal_context.attempt = 1; call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test2; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 2!"); call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test3; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 3!"); call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test4; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 4!"); call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test5; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT)|| (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test6; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); free(output.token); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued!"); call_function.call_srm2__srmLs = soap_call_srm2__srmLs_test7; result = srmv2_ls_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS)|| (result == -1), "Expected Success!"); } END_TEST int soap_call_srm2__srmStatusOfLs_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfLsRequestRequest *srmStatusOfLsRequest, struct srm2__srmStatusOfLsRequestResponse_ *_param_18) { _param_18->srmStatusOfLsRequestResponse = NULL; return 0; // success but return statuses are null } int soap_call_srm2__srmStatusOfLs_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfLsRequestRequest *srmStatusOfLsRequest, struct srm2__srmStatusOfLsRequestResponse_ *_param_18) { struct srm2__srmStatusOfLsRequestResponse *resp = (struct srm2__srmStatusOfLsRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfLsRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->details = NULL; _param_18->srmStatusOfLsRequestResponse = resp; return 0; // success } int soap_call_srm2__srmStatusOfLs_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfLsRequestRequest *srmStatusOfLsRequest, struct srm2__srmStatusOfLsRequestResponse_ *_param_18) { struct srm2__srmStatusOfLsRequestResponse *resp = (struct srm2__srmStatusOfLsRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfLsRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->details = NULL; _param_18->srmStatusOfLsRequestResponse = resp; return 0; // success } int soap_call_srm2__srmStatusOfLs_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfLsRequestRequest *srmStatusOfLsRequest, struct srm2__srmStatusOfLsRequestResponse_ *_param_18) { struct srm2__srmStatusOfLsRequestResponse *resp = (struct srm2__srmStatusOfLsRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfLsRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->details = (struct srm2__ArrayOfTMetaDataPathDetail*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTMetaDataPathDetail)); resp->details->__sizepathDetailArray = 1; resp->details->pathDetailArray = (struct srm2__TMetaDataPathDetail **) soap_malloc (soap,sizeof (struct srm2__TMetaDataPathDetail *)); resp->details->pathDetailArray[0] = (struct srm2__TMetaDataPathDetail *) soap_malloc (soap,sizeof (struct srm2__TMetaDataPathDetail )); resp->details->pathDetailArray[0] = NULL; _param_18->srmStatusOfLsRequestResponse = resp; return 0; // success } START_TEST (test_srmv2_status_of_ls_request) { int i; struct srm_ls_input input; struct srm_ls_output output; struct srm_context context; struct srm_internal_context internal_context; int result; input.offset = NULL; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function output.token = "test"; context.verbose = 0; context.errbuf = NULL; context.errbufsz = 0; context.srm_endpoint = "test"; call_function.call_srm2__srmStatusOfLsRequest = soap_call_srm2__srmStatusOfLs_test1; result = srmv2_status_of_ls_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure 1!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfLsRequest = soap_call_srm2__srmStatusOfLs_test2; result = srmv2_status_of_ls_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued in first call!"); for (i=0;i<15;i++) { result = srmv2_status_of_ls_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status == srm_call_status_SUCCESS) || (internal_context.current_status == srm_call_status_FAILURE), "Do not fail/succeed if queued,expected timeout after 10 calls!"); } fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfLsRequest = soap_call_srm2__srmStatusOfLs_test3; result = srmv2_status_of_ls_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfLsRequest = soap_call_srm2__srmStatusOfLs_test4; result = srmv2_status_of_ls_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS) || (result != 1), "Expected Success!"); } END_TEST void gfal_unittest_srmls_test_suite (Suite *s) { TCase *tc_case_1 = tcase_create ("SrmLs function tests"); tcase_add_checked_fixture (tc_case_1, NULL,NULL); tcase_add_test (tc_case_1, test_srmv2_ls_async); tcase_add_test (tc_case_1, test_srmv2_status_of_ls_request); tcase_add_test (tc_case_1, test_wait_for_new_attempt); suite_add_tcase (s, tc_case_1); } srm-ifce-1.18.0/src/srmv2_sync_wrapper.c0000644001662700052000000001170012217066060017077 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include "gfal_srm_ifce.h" #include "srmv2_sync_wrapper.h" int srmv2_ls_sync(struct srm_context *context,struct srm_ls_input *input,struct srm_ls_output *output) { struct srm_internal_context internal_context; int result; char * req_token; // Setup the timeout back_off_logic_init(context,&internal_context); // Call srm ls output->token = NULL; result = srmv2_ls_async_internal(context,input,output,&internal_context); internal_context.attempt = 1; req_token = output->token; // if ls was queued start polling statusOfLsRequest while ((internal_context.current_status == srm_call_status_QUEUED)&&(result >= 0)) { result = srmv2_status_of_ls_request_async_internal(context,input,output,&internal_context); if (internal_context.current_status == srm_call_status_TIMEOUT) { srmv2_abort_request(context, req_token); return -1; } // ls status of request } if (internal_context.current_status != srm_call_status_SUCCESS) { return -1; } return result; } int srmv2_prepare_to_put_sync(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { struct srm_internal_context internal_context; int result; // Setup the timeout back_off_logic_init(context,&internal_context); // request output->token = NULL; result = srmv2_prepare_to_put_async_internal(context,input,output,&internal_context); internal_context.attempt = 1; // if put was queued start polling statusOfPutRequest while ((internal_context.current_status == srm_call_status_QUEUED)&&(result >= 0)) { //srm_srmv2_pinfilestatus_delete(output->filestatuses, result); // srm_srm2__TReturnStatus_delete(output->retstatus); result = srmv2_status_of_put_request_async_internal(context,input,output,&internal_context); if (internal_context.current_status == srm_call_status_TIMEOUT) { srmv2_abort_request(context,output->token); errno = ETIMEDOUT; return -1; } } if (internal_context.current_status != srm_call_status_SUCCESS) { return -1; } return result; } int srmv2_prepare_to_get_sync(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { struct srm_internal_context internal_context; int result; // Setup the timeout back_off_logic_init(context,&internal_context); // request output->token = NULL; result = srmv2_prepare_to_get_async_internal(context,input,output,&internal_context); internal_context.attempt = 1; // if put was queued start polling statusOfPutRequest while ((internal_context.current_status == srm_call_status_QUEUED)&&(result >= 0)) { // srm_srmv2_pinfilestatus_delete(output->filestatuses, result); // srm_srm2__TReturnStatus_delete(output->retstatus); result = srmv2_status_of_get_request_async_internal(context,input,output,&internal_context); if (internal_context.current_status == srm_call_status_TIMEOUT) { srmv2_abort_request(context,output->token); errno = ETIMEDOUT; return -1; } } if (internal_context.current_status != srm_call_status_SUCCESS) { return -1; } return result; } int srmv2_bring_online_sync(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output) { struct srm_internal_context internal_context; int result; // Setup the timeout back_off_logic_init(context,&internal_context); // request output->token = NULL; result = srmv2_bring_online_async_internal(context,input,output,&internal_context); internal_context.attempt = 1; // if put was queued start polling statusOfPutRequest while ((internal_context.current_status == srm_call_status_QUEUED)&&(result >= 0)) { //srm_srmv2_pinfilestatus_delete(output->filestatuses, result); // srm_srm2__TReturnStatus_delete(output->retstatus); result = srmv2_status_of_bring_online_async_internal(context,input,output,&internal_context); if ((internal_context.current_status != srm_call_status_SUCCESS) &&(internal_context.current_status != srm_call_status_QUEUED) &&(result<0)) { srmv2_abort_request(context,output->token); return -1; } } if (internal_context.current_status != srm_call_status_SUCCESS) { return -1; } return result; } srm-ifce-1.18.0/src/gfal_srm_ifce_systemtest.c0000644001662700052000000006134112217066060020324 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include #include #include #include "gfal_srm_ifce_types.h" #include "gfal_srm_ifce.h" #include "srmv2_space_management_functions.h" #define MAX_PATH_LEN 1024 #define MAX_FILE_NAME_LEN 100 char test_srm_endpoint[MAX_PATH_LEN + MAX_FILE_NAME_LEN]; char test_file1[MAX_PATH_LEN + MAX_FILE_NAME_LEN]; char test_file2[MAX_PATH_LEN + MAX_FILE_NAME_LEN]; char test_unexisting[MAX_PATH_LEN + MAX_FILE_NAME_LEN]; char test_dir[MAX_PATH_LEN + MAX_FILE_NAME_LEN]; const char *test_vo; char *source_file = "file:///etc/group"; char *test_spacedescriptor = "srm_test_space"; void PrintResult(struct srmv2_mdfilestatus *print_output); void PrintPinFileStatuses(struct srmv2_pinfilestatus *statuses, int count); void TestPrepareToPutPrepareToGet(); void GlobusUrlCopy(char *sourceturl,char *destinationturl); int TestPurgeFromSpace(char** surls,char *token); int TestPutDone(char** surls,char *token); int TestAbortFiles(char **files,char *token); int TestBringOnline(char **files,char **protocols); int TestReleaseFiles(char **files,char *token); int TestPing(char *endpoint); int TestLs(char *surl); int DelSurl(int nbfiles,char **surls); int MkDir(char *directory); void CopyFile(char *file) { char *command; asprintf (&command, "lcg-cp --nobdii -D srmv2 --vo %s %s %s ", test_vo, source_file,file); //printf("%s \n",command); system(command); } void GlobusUrlCopy(char *sourceturl,char *destinationturl) { char* globus_url_copy; asprintf(&globus_url_copy,"globus-url-copy %s %s ",sourceturl,destinationturl); //printf("%s \n",globus_url_copy); system(globus_url_copy); } int FakeCopy(char *surl) // does prepare to put and put done without copying a single byte { char *surls[] = {surl}; int ret; char *protocols[] = {"file","gsiftp",NULL}; //"rfio","dcap","gsidcap","kdcap","" struct srm_context context; struct srm_preparetoput_input input_put; struct srm_preparetoput_output output_put; SRM_LONG64 filesizes[1] ={ 0 }; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_put.filesizes = filesizes; input_put.nbfiles = 1; input_put.desiredpintime = 1000; input_put.surls = surls; input_put.protocols = protocols; input_put.spacetokendesc = NULL; MkDir(test_dir); ret = srm_prepare_to_put(&context,&input_put,&output_put); if (ret!= -1) { ret = TestPutDone(surls,output_put.token); } return ret; } int DelDir(char *dir) { struct srm_context context; struct srm_rmdir_input input_rmdir; struct srm_rmdir_output output_rmdir; srm_context_init(&context,test_srm_endpoint,NULL,0,0); input_rmdir.recursive = 1; input_rmdir.surl = dir; return srm_rmdir(&context,&input_rmdir,&output_rmdir); } int DelSurl(int nbfiles,char **surls) { struct srm_context context; struct srm_rm_input rm_input; struct srm_rm_output rm_output; srm_context_init(&context,test_srm_endpoint,NULL,0,0); rm_input.nbfiles = nbfiles; rm_input.surls = surls; return srm_rm(&context,&rm_input,&rm_output); } int MkDir(char *directory) { struct srm_context context; struct srm_mkdir_input input_mkdir; char *test_surl_mkdir; char *test_surl_rmdir; asprintf(&test_surl_rmdir,"%s/test_dir",test_dir); asprintf(&test_surl_mkdir,"%s/test_dir/1/2",test_dir); srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_mkdir.dir_name = directory; return srm_mkdir(&context,&input_mkdir); } ////////////////////////////////////////////////////////////////// // test test_directory_functions ////////////////////////////////////////////////////////////////// START_TEST (test_directory_functions) { int a; struct srm_context context; struct srm_rm_input input_rm; struct srm_rm_output output_rm; struct srm_rmdir_input input_rmdir; struct srm_rmdir_output output_rmdir; struct srm_mkdir_input input_mkdir; int j; char *test_surls_rm[] = {test_file1}; char *test_surls_cleanup[] = {test_file1,test_file2}; char *test_surl_mkdir; char *test_surl_rmdir; asprintf(&test_surl_rmdir,"%s/test_dir",test_dir); asprintf(&test_surl_mkdir,"%s/test_dir/1/2",test_dir); srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; // clean up files and folders DelSurl(2,test_surls_cleanup); a = DelDir(test_dir); //printf("Remove dir:%s %d\n",input_rmdir.surl,a); a = TestLs(test_dir); //the error is in ls filestatuse fail_if ((a != -1), "Expected Unexistent Folder!"); CopyFile(test_file1); a = TestLs(test_dir); fail_if ((a != 1), "Expected One File!"); input_mkdir.dir_name = test_surl_mkdir; a = srm_mkdir(&context,&input_mkdir); //printf("Mkdir:%s %d \n",input_mkdir.dir_name,a); fail_if ((a != 0), "Expected Success!"); a = TestLs(test_surl_rmdir); fail_if ((a != 1), "Expected 1 File in this folder!"); a = TestLs(test_dir); fail_if ((a != 2), "Expected 2 Files in this folder!"); input_rmdir.recursive = 1; input_rmdir.surl = test_surl_rmdir; a = srm_rmdir(&context,&input_rmdir,&output_rmdir); //printf("Remove dir:%s %d\n",input_rmdir.surl,a); fail_if ((a != 1), "Expected Success!"); a = TestLs(test_dir); fail_if ((a != 1), "Expected 1 File in this folder!"); input_rm.nbfiles = 1; input_rm.surls = test_surls_rm; a = srm_rm(&context,&input_rm,&output_rm); fail_if ((a != 1), "Expected 1 File deleted!"); a = srm_rm(&context,&input_rm,&output_rm); fail_if ((a != 1), "Expected 1 File deleted!"); fail_if (( !output_rm.statuses || output_rm.statuses[0].status != ENOENT), "Expected no such file error!"); for(j=0;j0) { if (a>0 && b>0) { GlobusUrlCopy(output_get.filestatuses[0].turl,output_put.filestatuses[0].turl); } a = TestReleaseFiles(test_surls_get,output_get.token); fail_if ((a != 1), "Expected Success !"); b = TestPutDone(test_surls_put,output_put.token); fail_if ((b != 1), "Expected Success !"); input_get.surls = test_surls_unexisting; a = srm_prepare_to_get(&context,&input_get,&output_get); fail_if ((a != 1), "Expected Success !"); fail_if ((output_get.filestatuses[0].status != ENOENT), "Expected no such file or directory error!"); } DelSurl(1,test_surls_get); DelSurl(1,test_surls_put); DelDir(test_dir); } END_TEST ////////////////////////////////////////////////////////////////// // test test_srm_ping ////////////////////////////////////////////////////////////////// START_TEST (test_srm_ping) { struct srm_ping_output output; struct srm_context context; int result; context.version = VERSION_2_2; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1);; result = srm_ping(&context,&output); fail_if ((result != 0), "Expected Success !"); srm_set_timeout_connect(1); context.srm_endpoint = "test"; result = srm_ping(&context,&output); // returns 12? fail_if ((result == 0), "Expected Failure !"); srm_set_timeout_connect(60); } END_TEST ////////////////////////////////////////////////////////////////// // test test_srm_space_management ////////////////////////////////////////////////////////////////// START_TEST (test_srm_space_management) { struct srm_getspacemd_input input_metadata; struct srm_spacemd *spaces; struct srm_getbestspacetokens_input input_bestspacetoken; struct srm_getspacetokens_input input_get; struct srm_getspacetokens_output output_get; struct srm_reservespace_input input_reserve; struct srm_reservespace_output output_reserve1; struct srm_reservespace_output output_reserve2; struct srm_context context; int result,i; char *test_spacetoken_descriptor = test_spacedescriptor; char *best_spacetoken; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.version = VERSION_2_2; input_reserve.desired_lifetime = 100; input_reserve.desired_size = 1048576*2; // 2MB input_reserve.spacetokendescriptor = "srm_test_space"; input_get.spacetokendesc = test_spacetoken_descriptor; result = srmv2_getspacetokens (&context, &input_get, &output_get); for(i=0;iowner_permission != SRM_PERMISSION_RWX) , "Expected Success !"); fail_if ((!output.permissions || output.permissions->group_permissions_count != 1) , "Expected Success !"); DelSurl(1,surls); } END_TEST Suite * test_suite (void) { Suite *s = suite_create ("New srm interface communication with real endpoint test suit"); TCase *tc_case_1 = tcase_create ("T1"); TCase *tc_case_2 = tcase_create ("T2"); TCase *tc_case_3 = tcase_create ("T3"); TCase *tc_case_4 = tcase_create ("T4"); TCase *tc_case_5 = tcase_create ("T5"); tcase_add_checked_fixture (tc_case_1, NULL,NULL); tcase_add_test (tc_case_1, test_srm_ping); suite_add_tcase (s, tc_case_1); tcase_add_checked_fixture (tc_case_2, NULL,NULL); tcase_add_test (tc_case_2, test_data_transfer_functions); tcase_set_timeout(tc_case_2, 60); suite_add_tcase (s, tc_case_2); tcase_add_checked_fixture (tc_case_3, NULL,NULL); tcase_add_test (tc_case_3, test_directory_functions); tcase_set_timeout(tc_case_3, 60); suite_add_tcase (s, tc_case_3); tcase_add_checked_fixture (tc_case_4, NULL,NULL); tcase_add_test (tc_case_4, test_srm_space_management); tcase_set_timeout(tc_case_4, 60); suite_add_tcase (s, tc_case_4); tcase_add_checked_fixture (tc_case_5, NULL,NULL); tcase_add_test (tc_case_5, test_srm_permissions); tcase_set_timeout(tc_case_5, 60); suite_add_tcase (s, tc_case_5); return s; } int DoTests() { int number_failed; Suite *s = test_suite (); SRunner *sr = srunner_create (s); srunner_set_fork_status (sr,CK_NOFORK); // FOR EASIER DEBUG srunner_run_all (sr, CK_VERBOSE); number_failed = srunner_ntests_failed (sr); srunner_free (sr); return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; } void SetUp() { char* srm_host = getenv("SE_HOST_1"); if (! srm_host) { printf("\033[91mSE_HOST_1 environment variable not set!\033[0m"); exit(-1); } char* srm_path = getenv("SE_SRM_PATH_1"); if (! srm_path) { printf("\033[91mSE_SRM_PATH_1 environment variable not set!\033[0m"); exit(-1); } assert(strlen(srm_path) < MAX_PATH_LEN); assert(strlen(srm_host) < MAX_PATH_LEN); sprintf(test_srm_endpoint, "%s:8446/srm/managerv2", srm_host); sprintf(test_dir, "%s/srm_test", srm_path); sprintf(test_file1, "%s/test_file1", test_dir); sprintf(test_file2, "%s/test_file2", test_dir); sprintf(test_unexisting, "%s/unexisting", test_dir); test_vo = getenv("VO"); if (!test_vo) test_vo = "dteam"; printf("\nTest setup:\n\n"); printf("SRM host: %s\n", srm_host); printf("Test path: %s\n", test_dir); printf("VO Name: %s\n\n", test_vo); } /////////////////////////////////////////////// // MAIN /////////////////////////////////////////////// int main(void) { SetUp(); return DoTests(); } void PrintPinFileStatuses(struct srmv2_pinfilestatus *statuses, int count) { int i; for(i=0;i 0) { //PrintResult(output_ls.statuses); return ((output_ls.statuses)->nbsubpaths); } return i; } void PrintResult(struct srmv2_mdfilestatus *print_output) { int i; printf("Directory: %s \n",print_output->surl); printf("Files:\n"); for(i=0;inbsubpaths;i++) { printf("%s \n",print_output->subpaths[i].surl); } } int TestPutDone(char** surls,char *token) { struct srmv2_filestatus *filestatuses; int c; struct srm_putdone_input input_putdone; struct srm_context context; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_putdone.nbfiles = 1; input_putdone.surls = surls; input_putdone.reqtoken = token; c = srm_put_done(&context,&input_putdone,&filestatuses); //printf("Put Done\nToken: %s \nSurl: %s\nResult: %d\n",token,surls[0],c); return c; } int TestPurgeFromSpace(char** surls,char *token) { int c; struct srm_purgefromspace_input input_purge; struct srm_purgefromspace_output output_purge; struct srm_context context; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_purge.nbfiles = 1; input_purge.surls = surls; input_purge.spacetoken = token; c = srm_purgefromspace(&context,&input_purge,&output_purge); //printf("Put Done\nToken: %s \nSurl: %s\nResult: %d\n",token,surls[0],c); return c; } int TestAbortRequest(char *token) { int c; struct srm_context context; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; c = srm_abort_request(&context,token); //printf("Abort request\nToken: %s \nResult: %d\n",token,c); return c; } int TestAbortFiles(char **files,char *token) { struct srmv2_filestatus *filestatuses; int c; struct srm_context context; struct srm_abort_files_input input; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input.nbfiles = 1; input.surls = files; input.reqtoken = token; c = srm_abort_files(&context,&input,&filestatuses); //printf("Abort files\nFile: %s\nToken: %s \nResult: %d\n",files[0],token,c); return c; } int TestReleaseFiles(char **files,char *token) { struct srmv2_filestatus *filestatuses; int a; struct srm_context context; struct srm_releasefiles_input input; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input.nbfiles = 1; input.surls = files; input.reqtoken = token; a = srm_release_files(&context,&input,&filestatuses); //printf("Release files\nFile: %s\nToken: %s \nResult: %d\n",files[0],token,a); return a; } int TestBringOnline(char **files,char **protocols) { struct srm_context context; struct srm_bringonline_input input_bringonline; struct srm_bringonline_output output_bringonline; int a; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_bringonline.desiredpintime = 1000; input_bringonline.nbfiles = 1; input_bringonline.protocols = protocols; input_bringonline.surls = files; input_bringonline.spacetokendesc = NULL; a = srm_bring_online(&context,&input_bringonline,&output_bringonline); //printf("BRING ONLINE \n"); //PrintPinFileStatuses(output_bringonline.filestatuses,a); return a; } void TestSpaceTokensSpaceMetadata() { int a; struct srm_context context; struct srm_getbestspacetokens_input input_bestspacetokens; struct srm_getspacemd_input input_md; struct srm_spacemd *spacemd; struct srm_getspacetokens_input input_space_tokens; struct srm_getspacetokens_output output_space_tokens; srm_context_init(&context, test_srm_endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; input_space_tokens.spacetokendesc = "NULL"; //output_space_tokens. a = srm_getspacetokens(&context,&input_space_tokens,&output_space_tokens); //input_md pseudo = output_space_tokens input_md.nbtokens = 0; input_md.spacetokens = NULL; a = srm_getspacemd(&context,&input_md,&spacemd); input_bestspacetokens.neededsize = 1000; //input_bestspacetokens.spacetokendesc = ....; srm_getbestspacetoken(&context,&input_bestspacetokens); } int TestPing(char *endpoint) { int a; struct srm_context context; struct srm_ping_output output; srm_context_init(&context, endpoint, NULL, 0, 1); context.timeout = 3600; context.version = VERSION_2_2; a = srm_ping(&context,&output); if (a == 0) { //printf("Ping result: %s\n",output.versioninfo); }else { //printf("Ping error \n",output.versioninfo); } return a; } srm-ifce-1.18.0/src/srmv2_sync_wrapper.h0000644001662700052000000000256712217066060017117 0ustar adevresscg#pragma once #ifndef _SRMV2_SYNC_WRAPPER_H_ #define _SRMV2_SYNC_WRAPPER_H_ /* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_ifce_internal.h" int srmv2_ls_sync(struct srm_context *context,struct srm_ls_input *input,struct srm_ls_output *output); int srmv2_prepare_to_put_sync(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output); int srmv2_prepare_to_get_sync(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output); int srmv2_bring_online_sync(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output); #endif srm-ifce-1.18.0/src/time_utils.h0000644001662700052000000000472612217066060015427 0ustar adevresscg#pragma once #ifndef _TIME_UTILS_H #define _TIME_UTILS_H /** similar to timeradd, timercmp, etc... function but for timerspec */ #define timespec_cmp(a, b, CMP) \ (((a)->tv_sec == (b)->tv_sec) ? \ ((a)->tv_nsec CMP (b)->tv_nsec) : \ ((a)->tv_sec CMP (b)->tv_sec)) #define timespec_add(a, b, result) \ do { \ (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \ (result)->tv_nsec = (a)->tv_nsec + (b)->tv_nsec; \ if ((result)->tv_nsec > 1000000000) { \ ++(result)->tv_sec; \ (result)->tv_nsec -= 1000000000; \ } \ } while (0) #define timespec_sub(a, b, result) \ do { \ (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ (result)->tv_nsec = (a)->tv_nsec - (b)->tv_nsec; \ if ((result)->tv_nsec < 0) { \ --(result)->tv_sec; \ (result)->tv_nsec += 1000000000; \ } \ } while (0) #define timespec_clear(a) \ do { \ (a)->tv_sec = 0; \ (a)->tv_nsec = 0; \ } while (0) #define timespec_copy(result,b) \ do { \ (result)->tv_sec =(b)->tv_sec; \ (result)->tv_nsec = (b)->tv_nsec; \ } while (0) #define timespec_isset(a) \ ( !((a)->tv_sec == 0 && (a)->tv_nsec == 0) ) #endif srm-ifce-1.18.0/src/srmv2_async_wrapper.c0000644001662700052000000000647412217066060017254 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srmv2_async_wrapper.h" int srmv2_ls_async(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_ls_async_internal(context,input,output,&internal_context); } int srmv2_status_of_ls_async(struct srm_context *context, struct srm_ls_input *input, struct srm_ls_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_status_of_ls_request_async_internal(context,input,output,&internal_context); } int srmv2_prepare_to_get_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_prepare_to_get_async_internal(context,input,output,&internal_context); } int srmv2_status_of_get_request_async(struct srm_context *context, struct srm_preparetoget_input *input, struct srm_preparetoget_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_status_of_get_request_async_internal(context,input,output,&internal_context); } int srmv2_prepare_to_put_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_prepare_to_put_async_internal(context,input,output,&internal_context); } int srmv2_status_of_put_request_async(struct srm_context *context, struct srm_preparetoput_input *input, struct srm_preparetoput_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_status_of_put_request_async_internal(context,input,output,&internal_context); } int srmv2_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_bring_online_async_internal(context,input,output,&internal_context); } int srmv2_status_of_bring_online_async(struct srm_context *context, struct srm_bringonline_input *input, struct srm_bringonline_output *output) { struct srm_internal_context internal_context; back_off_logic_init(context,&internal_context); return srmv2_status_of_bring_online_async_internal(context,input,output,&internal_context); } srm-ifce-1.18.0/src/srm.v1.1.wsdl0000644001662700052000000004016412217066060015254 0ustar adevresscg diskCacheV111.srm.server.SRMServerV1 web service srm-ifce-1.18.0/src/gfal_srm_ifce_unittest.c0000644001662700052000000041151112217066060017755 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include #include #include #include #include #include #include "srmv2H.h" #include "gfal_srm_ifce_types.h" #include "srm_util.h" #include "srm_soap.h" #include "gfal_srm_ifce_unittest.h" #include "srmv2_data_transfer_functions.h" char test_dir[] = "/test/1/2/3/4"; char* fixture_test_strings[3]= { "fixture_test_string1","fixture_test_string2",NULL}; void PrintResult(struct srmv2_mdfilestatus* output); START_TEST (test_wait_for_new_attempt) { call_function.call_sleep = mock_sleep; int i; struct srm_internal_context internal_context; internal_context.estimated_wait_time = -1; internal_context.attempt = 11; fail_if (wait_for_new_attempt(&internal_context) != -1, "Wait for new attempt does not return timeout error for 11 attempts!"); internal_context.attempt = 5; internal_context.end_time = time(NULL)-20; fail_if (wait_for_new_attempt(&internal_context) != -1, "Timeout error not received!"); call_function.call_sleep = mock_sleep; internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; fail_if (wait_for_new_attempt(&internal_context) != 0, "Timeout should not occur!"); fail_if (mock_sleep_time > 1, // be careful changing this number "Random sleep time exceeded expected value !!!"); internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; internal_context.estimated_wait_time = 0; fail_if (wait_for_new_attempt(&internal_context) != 0, "Timeout should not occur, estimated wait time == 0 ignored !"); internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+100; internal_context.estimated_wait_time = -10; fail_if (mock_sleep_time > 1, // be careful changing this number "Random sleep time exceeded expected value !!!"); internal_context.attempt = 1; // be careful changing this number for(i=0; i < 8; ++i){ // simple backoff print to evaluate value wait_for_new_attempt(&internal_context); fprintf(stdout, " backoff timeout attempt : %d, sleep_time : %d \n",i ,mock_sleep_time); } internal_context.estimated_wait_time = 2; wait_for_new_attempt(&internal_context); fail_if (mock_sleep_time != 10, "Sleep time estimated wait time not equal to sleep time!"); } END_TEST START_TEST (test_wait_ng) { int i; srm_context_t context = srm_context_new("test",NULL,0,0); struct srm_internal_context internal_context; back_off_logic_init(context, &internal_context); gboolean timeout = FALSE; long total_wait_time = 0; for(i=0;i <100;++i){ time_t t1 = time(NULL); timeout = (wait_for_new_attempt_min_max_ng(context, &internal_context) ==0)?timeout:TRUE; printf(" wait for %d : %ld \n", i, time(NULL)- t1); total_wait_time += (time(NULL)- t1); } fail_if(timeout == FALSE, " should go to timeout, to much iteration..."); printf(" total timeout %ld \n", total_wait_time); fail_if(total_wait_time < context->timeout-2 && total_wait_time > context->timeout+2, "not in the timeout range"); srm_context_free(context); } END_TEST ////////////////////////////////////////////////////////////////// // test wait_for_new_attempt function ////////////////////////////////////////////////////////////////// START_TEST (test_back_off_logic) { const char *srmfunc = "testfunc"; struct srm_context context; struct srm_internal_context internal_context; struct srm2__TReturnStatus retstatus; srm_call_status result; srm_context_init(&context,"test",NULL,0,0); call_function.call_sleep = mock_sleep; // set mock sleep function internal_context.estimated_wait_time = -1; internal_context.attempt = 1; // be careful changing this number internal_context.end_time = time(NULL)+10000; result = back_off_logic(&context,srmfunc,&internal_context,NULL); fail_if ((result != srm_call_status_FAILURE)||(errno != ECOMM), "if internal_context->retstatus is NULL the function must return FAILURE!"); retstatus.statusCode = SRM_USCOREINTERNAL_USCOREERROR; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((internal_context.attempt != 2), "Wait new attempt!"); fail_if ((result != srm_call_status_INTERNAL_ERROR), "Expected Internal Error!"); internal_context.attempt = 11; retstatus.statusCode = SRM_USCOREINTERNAL_USCOREERROR; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_TIMEOUT), "Expected Timeout 1!"); internal_context.attempt = 11; retstatus.statusCode = SRM_USCOREREQUEST_USCOREQUEUED; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_TIMEOUT), "Expected Timeout 2!"); internal_context.attempt = 11; retstatus.statusCode = SRM_USCOREREQUEST_USCOREINPROGRESS; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_TIMEOUT), "Expected Timeout 3!"); internal_context.attempt = 1; retstatus.statusCode = SRM_USCOREREQUEST_USCOREQUEUED; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_QUEUED), "Expected Queued 1!"); internal_context.attempt = 1; retstatus.statusCode = SRM_USCOREREQUEST_USCOREINPROGRESS; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_QUEUED), "Expected Queued 2!"); internal_context.attempt = 1; retstatus.statusCode = SRM_USCORESUCCESS; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_SUCCESS), "Expected Success!"); internal_context.attempt = 1; retstatus.statusCode = SRM_USCOREFAILURE; result = back_off_logic(&context,srmfunc,&internal_context,&retstatus); fail_if ((result != srm_call_status_FAILURE), "Expected Failure!"); } END_TEST int soap_call_srm2__abort_request_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortRequestRequest *request, struct srm2__srmAbortRequestResponse_ *_param_18) { _param_18 = NULL; return 0; } int soap_call_srm2__abort_request_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortRequestRequest *request, struct srm2__srmAbortRequestResponse_ *_param_18) { return -1; } int soap_call_srm2__abort_request_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortRequestRequest *request, struct srm2__srmAbortRequestResponse_ *_param_18) { struct srm2__srmAbortRequestResponse *resp = (struct srm2__srmAbortRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmAbortRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; // Failure retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmAbortRequestResponse = resp; return 0; // success } int soap_call_srm2__abort_request_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortRequestRequest *request, struct srm2__srmAbortRequestResponse_ *_param_18) { struct srm2__srmAbortRequestResponse *resp = (struct srm2__srmAbortRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmAbortRequestResponse)); resp->returnStatus = NULL; // FAILURE _param_18->srmAbortRequestResponse = resp; return 0; // success } int soap_call_srm2__abort_request_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortRequestRequest *request, struct srm2__srmAbortRequestResponse_ *_param_18) { struct srm2__srmAbortRequestResponse *resp = (struct srm2__srmAbortRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmAbortRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmAbortRequestResponse = resp; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_abort_request ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_abort_request) { const char *token = "testtoken"; struct srm_context context; srm_call_status result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context,"test",NULL,0,0); call_function.call_srm2__srmAbortRequest = soap_call_srm2__abort_request_test1; result = srmv2_abort_request(&context,NULL); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmAbortRequest = soap_call_srm2__abort_request_test2; result = srmv2_abort_request(&context, (char*)token); fail_if ((result != -1), "Expected Failure!"); call_function.call_srm2__srmAbortRequest = soap_call_srm2__abort_request_test3; result = srmv2_abort_request(&context, (char*)token); fail_if ((result != -1), "Expected Failure!"); call_function.call_srm2__srmAbortRequest = soap_call_srm2__abort_request_test4; result = srmv2_abort_request(&context, (char*)token); fail_if ((result != -1), "Expected Failure!"); call_function.call_srm2__srmAbortRequest = soap_call_srm2__abort_request_test5; result = srmv2_abort_request(&context, (char*)token); fail_if ((result != 0), "Expected Success!"); } END_TEST int soap_call_srm2__srmRmDir_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmRmdirRequest *srmRmdirRequest, struct srm2__srmRmdirResponse_ *_param_18) { struct srm2__srmRmdirResponse *resp = (struct srm2__srmRmdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmRmdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmRmdirResponse = resp; return 0; } int soap_call_srm2__srmRmDir_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmRmdirRequest *srmRmdirRequest, struct srm2__srmRmdirResponse_ *_param_18) { _param_18->srmRmdirResponse = NULL; return -1; } int soap_call_srm2__srmRmDir_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmRmdirRequest *srmRmdirRequest, struct srm2__srmRmdirResponse_ *_param_18) { struct srm2__srmRmdirResponse *resp = (struct srm2__srmRmdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmRmdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmRmdirResponse = resp; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_rmdir ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_rmdir) { struct srm_rmdir_input input; struct srm_rmdir_output output; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.surl = fixture_test_string; input.recursive = 0; call_function.call_srm2__srmRmdir = soap_call_srm2__srmRmDir_test1; result = srmv2_rmdir(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != 1), "Expected Success!"); call_function.call_srm2__srmRmdir = soap_call_srm2__srmRmDir_test2; result = srmv2_rmdir(&context,&input,&output); fail_if ((result != -1), "Expected Failure 2!"); call_function.call_srm2__srmRmdir = soap_call_srm2__srmRmDir_test3; result = srmv2_rmdir(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != 1), "Expected Success!"); } END_TEST int soap_call_srm2__srmRm_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmRmRequest *srmRmRequest, struct srm2__srmRmResponse_ *_param_18) { struct srm2__srmRmResponse *resp = (struct srm2__srmRmResponse *) soap_malloc (soap,sizeof (struct srm2__srmRmResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmRmResponse = resp; return 0; } int soap_call_srm2__srmRm_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmRmRequest *srmRmRequest, struct srm2__srmRmResponse_ *_param_18) { struct srm2__srmRmResponse *resp = (struct srm2__srmRmResponse *) soap_malloc (soap,sizeof (struct srm2__srmRmResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmRmResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } ////////////////////////////////////////////////////////////////// // test test_srmv2_rm ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_rm) { struct srm_rm_input input; struct srm_rm_output output; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.surls = fixture_test_strings; input.nbfiles = 1; call_function.call_srm2__srmRm = soap_call_srm2__srmRm_test1; result = srmv2_rm(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmRm = soap_call_srm2__srmRm_test2; result = srmv2_rm(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != 1), "Expected Success!"); } END_TEST int soap_call_srm2__srmMkdir_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmMkdirRequest *srmMkdirRequest, struct srm2__srmMkdirResponse_ *_param_18) { struct srm2__srmMkdirResponse *resp = (struct srm2__srmMkdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmMkdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmMkdirResponse = resp; return 0; } int soap_call_srm2__srmMkdir_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmMkdirRequest *srmMkdirRequest, struct srm2__srmMkdirResponse_ *_param_18) { struct srm2__srmMkdirResponse *resp = (struct srm2__srmMkdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmMkdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmMkdirResponse = resp; return 0; } int soap_call_srm2__srmMkdir_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmMkdirRequest *srmMkdirRequest, struct srm2__srmMkdirResponse_ *_param_18) { struct srm2__srmMkdirResponse *resp = (struct srm2__srmMkdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmMkdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREDUPLICATION_USCOREERROR; // dir already exist retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmMkdirResponse = resp; return 0; } int mkdir_test_ok = 0; int soap_call_srm2__srmMkdir_test_last_level(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmMkdirRequest *srmMkdirRequest, struct srm2__srmMkdirResponse_ *_param_18) { int i,n; struct srm2__srmMkdirResponse *resp = (struct srm2__srmMkdirResponse *) soap_malloc (soap,sizeof (struct srm2__srmMkdirResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmMkdirResponse = resp; mkdir_test_ok = 0; n = strlen(test_dir); // Check if we create the full directory not using strcmp because of last slash char for(i=0;iSURL);i++) { if (srmMkdirRequest->SURL[i] != test_dir[i]) { break; } } if ((i == n) || (i == (n-1) && test_dir[n-1] == '/')) { mkdir_test_ok = 1; } return 0; } ////////////////////////////////////////////////////////////////// // test test_srmv2_mkdir ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_mkdir) { struct srm_mkdir_input input; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.dir_name = test_dir; call_function.call_srm2__srmMkdir = soap_call_srm2__srmMkdir_test1; result = srmv2_mkdir(&context,&input); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmMkdir = soap_call_srm2__srmMkdir_test2; result = srmv2_mkdir(&context,&input); fail_if ((result != 0), "Expected Success!"); /*call_function.call_srm2__srmMkdir = soap_call_srm2__srmMkdir_test3; result = srmv2_mkdir(&context,&input); fail_if ((result != -1), "Expected Failure 1!"); */ call_function.call_srm2__srmMkdir = soap_call_srm2__srmMkdir_test_last_level; result = srmv2_mkdir(&context,&input); fail_if ((result != 0), "Expected Success!"); fail_if ((mkdir_test_ok != 1), "Expected Success!"); } END_TEST int soap_call_srm2__srmAbortFiles_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortFilesRequest *srmAbortFilesRequest, struct srm2__srmAbortFilesResponse_ *_param_18) { struct srm2__srmAbortFilesResponse *resp = (struct srm2__srmAbortFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmAbortFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINVALID_USCOREREQUEST; // token empty retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmAbortFilesResponse = resp; return 0; } int soap_call_srm2__srmAbortFiles_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmAbortFilesRequest *srmAbortFilesRequest, struct srm2__srmAbortFilesResponse_ *_param_18) { struct srm2__srmAbortFilesResponse *resp = (struct srm2__srmAbortFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmAbortFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; // token empty retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmAbortFilesResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } ////////////////////////////////////////////////////////////////// // test test_abort_files ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_abort_files) { char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; struct srmv2_filestatus *statuses; struct srm_abort_files_input input; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.surls = test_surls; input.reqtoken = "test"; call_function.call_srm2__srmAbortFiles = soap_call_srm2__srmAbortFiles_test1; result = srmv2_abort_files(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmAbortFiles = soap_call_srm2__srmAbortFiles_test2; result = srmv2_abort_files(&context,&input,&statuses); fail_if ((result == -1), "Expected Success!"); } END_TEST int soap_call_srm2__srmPutDone_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPutDoneRequest *srmAbortFilesRequest, struct srm2__srmPutDoneResponse_ *_param_18) { struct srm2__srmPutDoneResponse *resp = (struct srm2__srmPutDoneResponse *) soap_malloc (soap,sizeof (struct srm2__srmPutDoneResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINVALID_USCOREREQUEST; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPutDoneResponse = resp; return 0; } int soap_call_srm2__srmPutDone_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPutDoneRequest *srmAbortFilesRequest, struct srm2__srmPutDoneResponse_ *_param_18) { struct srm2__srmPutDoneResponse *resp = (struct srm2__srmPutDoneResponse *) soap_malloc (soap,sizeof (struct srm2__srmPutDoneResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmPutDoneResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } int soap_call_srm2__srmPutDone_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPutDoneRequest *srmAbortFilesRequest, struct srm2__srmPutDoneResponse_ *_param_18) { struct srm2__srmPutDoneResponse *resp = (struct srm2__srmPutDoneResponse *) soap_malloc (soap,sizeof (struct srm2__srmPutDoneResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmPutDoneResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } int soap_call_srm2__srmPutDone_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPutDoneRequest *srmAbortFilesRequest, struct srm2__srmPutDoneResponse_ *_param_18) { struct srm2__srmPutDoneResponse *resp = (struct srm2__srmPutDoneResponse *) soap_malloc (soap,sizeof (struct srm2__srmPutDoneResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPutDoneResponse = NULL; // THIS FAILS return 0; } int soap_call_srm2__srmPutDone_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPutDoneRequest *srmAbortFilesRequest, struct srm2__srmPutDoneResponse_ *_param_18) { struct srm2__srmPutDoneResponse *resp = (struct srm2__srmPutDoneResponse *) soap_malloc (soap,sizeof (struct srm2__srmPutDoneResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = NULL;// THIS FAILS resp->arrayOfFileStatuses = NULL; _param_18->srmPutDoneResponse = resp; return 0; } ////////////////////////////////////////////////////////////////// // test test_put_done ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_put_done) { char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; struct srmv2_filestatus *statuses; struct srm_putdone_input input; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.surls = test_surls; input.reqtoken = "test"; call_function.call_srm2__srmPutDone = soap_call_srm2__srmPutDone_test1; result = srmv2_put_done(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmPutDone = soap_call_srm2__srmPutDone_test2; result = srmv2_put_done(&context,&input,&statuses); fail_if ((result == -1), "Expected Success!"); call_function.call_srm2__srmPutDone = soap_call_srm2__srmPutDone_test3; result = srmv2_put_done(&context,&input,&statuses); fail_if ((result == -1), "Expected Success!"); call_function.call_srm2__srmPutDone = soap_call_srm2__srmPutDone_test4; result = srmv2_put_done(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure!"); call_function.call_srm2__srmPutDone = soap_call_srm2__srmPutDone_test5; result = srmv2_put_done(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure!"); } END_TEST int soap_call_srm2__srmReleaseFiles_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmReleaseFilesRequest *srmAbortFilesRequest, struct srm2__srmReleaseFilesResponse_ *_param_18) { struct srm2__srmReleaseFilesResponse *resp = (struct srm2__srmReleaseFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmReleaseFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINVALID_USCOREREQUEST; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmReleaseFilesResponse = resp; return 0; } int soap_call_srm2__srmReleaseFiles_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmReleaseFilesRequest *srmAbortFilesRequest, struct srm2__srmReleaseFilesResponse_ *_param_18) { struct srm2__srmReleaseFilesResponse *resp = (struct srm2__srmReleaseFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmReleaseFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmReleaseFilesResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } int soap_call_srm2__srmReleaseFiles_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmReleaseFilesRequest *srmAbortFilesRequest, struct srm2__srmReleaseFilesResponse_ *_param_18) { struct srm2__srmReleaseFilesResponse *resp = (struct srm2__srmReleaseFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmReleaseFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmReleaseFilesResponse = resp; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLReturnStatus *)soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; return 0; } int soap_call_srm2__srmReleaseFiles_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmReleaseFilesRequest *srmAbortFilesRequest, struct srm2__srmReleaseFilesResponse_ *_param_18) { struct srm2__srmReleaseFilesResponse *resp = (struct srm2__srmReleaseFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmReleaseFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmReleaseFilesResponse = NULL; // THIS FAILS return 0; } int soap_call_srm2__srmReleaseFiles_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmReleaseFilesRequest *srmAbortFilesRequest, struct srm2__srmReleaseFilesResponse_ *_param_18) { struct srm2__srmReleaseFilesResponse *resp = (struct srm2__srmReleaseFilesResponse *) soap_malloc (soap,sizeof (struct srm2__srmReleaseFilesResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = NULL;// THIS FAILS resp->arrayOfFileStatuses = NULL; _param_18->srmReleaseFilesResponse = resp; return 0; } ////////////////////////////////////////////////////////////////// // test test_release_files ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_release_files) { char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; struct srmv2_filestatus *statuses; struct srm_releasefiles_input input; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.surls = test_surls; input.reqtoken = "test"; call_function.call_srm2__srmReleaseFiles = soap_call_srm2__srmReleaseFiles_test1; result = srmv2_release_files(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure 1!"); call_function.call_srm2__srmReleaseFiles = soap_call_srm2__srmReleaseFiles_test2; result = srmv2_release_files(&context,&input,&statuses); fail_if ((result == -1), "Expected Success!"); call_function.call_srm2__srmReleaseFiles = soap_call_srm2__srmReleaseFiles_test3; result = srmv2_release_files(&context,&input,&statuses); fail_if ((result == -1), "Expected Success!"); call_function.call_srm2__srmReleaseFiles = soap_call_srm2__srmReleaseFiles_test4; result = srmv2_release_files(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure!"); call_function.call_srm2__srmReleaseFiles = soap_call_srm2__srmReleaseFiles_test5; result = srmv2_release_files(&context,&input,&statuses); fail_if ((result != -1), "Expected Failure!"); } END_TEST int soap_call_srm2__srmBringOnline_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); resp->returnStatus = NULL; resp->remainingTotalRequestTime = NULL; resp->requestToken = NULL; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; return 0; // success but return statuses are NULL } int soap_call_srm2__srmBringOnline_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->remainingTotalRequestTime = NULL; resp->requestToken = NULL; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; return -1; // failure } int soap_call_srm2__srmBringOnline_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); resp->returnStatus = retstatus; resp->remainingTotalRequestTime = NULL; resp->requestToken = NULL; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; retstatus->statusCode = SRM_USCOREPARTIAL_USCORESUCCESS; retstatus->explanation = NULL; return 0; // success } int soap_call_srm2__srmBringOnline_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->requestToken = NULL; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; _param_18->srmBringOnlineResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmBringOnline_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->requestToken = NULL; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; _param_18->srmBringOnlineResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmBringOnline_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->requestToken = fixture_test_string; resp->arrayOfFileStatuses = NULL; _param_18->srmBringOnlineResponse = resp; _param_18->srmBringOnlineResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmBringOnline_test7(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmBringOnlineRequest *srmBringOnlineRequest, struct srm2__srmBringOnlineResponse_ *_param_18) { struct srm2__srmBringOnlineResponse *resp = (struct srm2__srmBringOnlineResponse *) soap_malloc (soap,sizeof (struct srm2__srmBringOnlineResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmBringOnlineResponse = resp; _param_18->srmBringOnlineResponse->remainingTotalRequestTime = NULL; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTBringOnlineRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTBringOnlineRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TBringOnlineRequestFileStatus**) soap_malloc (soap,sizeof (struct srm2__TBringOnlineRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TBringOnlineRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__TBringOnlineRequestFileStatus)); resp->arrayOfFileStatuses->statusArray[0] = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_ls_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_bring_online_async) { struct srm_bringonline_input input; struct srm_bringonline_output output; struct srmv2_pinfilestatus filestatus; struct srm_context context; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... getbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test1; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 1!"); call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test2; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 2!"); call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test3; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 3!"); call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test4; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 4!"); call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test5; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT)|| (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test6; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); free(output.token); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued!"); output.filestatuses = &filestatus; call_function.call_srm2__srmBringOnline = soap_call_srm2__srmBringOnline_test7; result = srmv2_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS)|| (result == -1), "Expected Success!"); } END_TEST int soap_call_srm2__srmStatusOfBringOnline_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfBringOnlineRequestRequest *srmStatusOfBringOnlineRequest, struct srm2__srmStatusOfBringOnlineRequestResponse_ *_param_18) { _param_18->srmStatusOfBringOnlineRequestResponse = NULL; return 0; // success but return statuses are NULL } int soap_call_srm2__srmStatusOfBringOnline_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfBringOnlineRequestRequest *srmStatusOfBringOnlineRequest, struct srm2__srmStatusOfBringOnlineRequestResponse_ *_param_18) { struct srm2__srmStatusOfBringOnlineRequestResponse *resp = (struct srm2__srmStatusOfBringOnlineRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfBringOnlineRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmStatusOfBringOnlineRequestResponse = resp; _param_18->srmStatusOfBringOnlineRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfBringOnline_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfBringOnlineRequestRequest *srmStatusOfBringOnlineRequest, struct srm2__srmStatusOfBringOnlineRequestResponse_ *_param_18) { struct srm2__srmStatusOfBringOnlineRequestResponse *resp = (struct srm2__srmStatusOfBringOnlineRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfBringOnlineRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmStatusOfBringOnlineRequestResponse = resp; _param_18->srmStatusOfBringOnlineRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfBringOnline_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfBringOnlineRequestRequest *srmStatusOfBringOnlineRequest, struct srm2__srmStatusOfBringOnlineRequestResponse_ *_param_18) { struct srm2__srmStatusOfBringOnlineRequestResponse *resp = (struct srm2__srmStatusOfBringOnlineRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfBringOnlineRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTBringOnlineRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTBringOnlineRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TBringOnlineRequestFileStatus**) soap_malloc (soap,sizeof (struct srm2__TBringOnlineRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TBringOnlineRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__TBringOnlineRequestFileStatus)); resp->arrayOfFileStatuses->statusArray[0] = NULL; _param_18->srmStatusOfBringOnlineRequestResponse = resp; _param_18->srmStatusOfBringOnlineRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfBringOnline_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfBringOnlineRequestRequest *srmStatusOfBringOnlineRequest, struct srm2__srmStatusOfBringOnlineRequestResponse_ *_param_18) { struct srm2__srmStatusOfBringOnlineRequestResponse *resp = (struct srm2__srmStatusOfBringOnlineRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfBringOnlineRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; // FAILS _param_18->srmStatusOfBringOnlineRequestResponse = resp; _param_18->srmStatusOfBringOnlineRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_status_of_bring_online ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_status_of_bring_online_async) { int i; struct srm_bringonline_input input; struct srm_bringonline_output output; struct srmv2_pinfilestatus filestatus; struct srm_context context; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... getbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmStatusOfBringOnlineRequest = soap_call_srm2__srmStatusOfBringOnline_test1; result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure 1!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfBringOnlineRequest = soap_call_srm2__srmStatusOfBringOnline_test2; result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued in first call!"); for (i=0;i<15;i++) { result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status == srm_call_status_SUCCESS) || (internal_context.current_status == srm_call_status_FAILURE), "Do not fail/succeed if queued,expected timeout after 10 calls.!"); } fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfBringOnlineRequest = soap_call_srm2__srmStatusOfBringOnline_test3; result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; output.filestatuses= &filestatus; call_function.call_srm2__srmStatusOfBringOnlineRequest = soap_call_srm2__srmStatusOfBringOnline_test4; result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS) || (result == -1), "Expected Success!"); call_function.call_srm2__srmStatusOfBringOnlineRequest = soap_call_srm2__srmStatusOfBringOnline_test5; result = srmv2_status_of_bring_online_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure!"); } END_TEST int soap_call_srm2__srmPrepareToGet_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { _param_18->srmPrepareToGetResponse = NULL; return 0; // success but return statuses are NULL } int soap_call_srm2__srmPrepareToGet_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmBringOnlineRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; return -1; // failure } int soap_call_srm2__srmPrepareToGet_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; retstatus->statusCode = SRM_USCOREPARTIAL_USCORESUCCESS; retstatus->explanation = NULL; return 0; // success } int soap_call_srm2__srmPrepareToGet_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = NULL; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToGet_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = NULL; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToGet_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = fixture_test_string; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToGet_test7(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToGetRequest *srmPrepareToGetRequest, struct srm2__srmPrepareToGetResponse_ *_param_18) { struct srm2__srmPrepareToGetResponse *resp = (struct srm2__srmPrepareToGetResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToGetResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmPrepareToGetResponse = resp; _param_18->srmPrepareToGetResponse->remainingTotalRequestTime = NULL; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTGetRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTGetRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TGetRequestFileStatus **) soap_malloc (soap,sizeof (struct srm2__TGetRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TGetRequestFileStatus *) soap_malloc (soap,sizeof (struct srm2__TGetRequestFileStatus )); resp->arrayOfFileStatuses->statusArray[0] = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_prepare_to_get_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_prepare_to_get_async) { struct srm_preparetoget_input input; struct srm_preparetoget_output output; struct srmv2_pinfilestatus filestatus; struct srm_context context; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... getbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test1; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 1!"); call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test2; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 2!"); call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test3; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 3!"); call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test4; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 4!"); call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test5; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT)|| (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test6; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); free(output.token); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued!"); output.filestatuses = &filestatus; call_function.call_srm2__srmPrepareToGet = soap_call_srm2__srmPrepareToGet_test7; result = srmv2_prepare_to_get_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS)|| (result == -1), "Expected Success!"); } END_TEST int soap_call_srm2__srmStatusOfGet_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfGetRequestRequest *srmStatusOfGetRequest, struct srm2__srmStatusOfGetRequestResponse_ *_param_18) { _param_18->srmStatusOfGetRequestResponse = NULL; return 0; // success but return statuses are NULL } int soap_call_srm2__srmStatusOfGet_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfGetRequestRequest *srmStatusOfGetRequest, struct srm2__srmStatusOfGetRequestResponse_ *_param_18) { struct srm2__srmStatusOfGetRequestResponse *resp = (struct srm2__srmStatusOfGetRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfGetRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmStatusOfGetRequestResponse = resp; _param_18->srmStatusOfGetRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfGet_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfGetRequestRequest *srmStatusOfGetRequest, struct srm2__srmStatusOfGetRequestResponse_ *_param_18) { struct srm2__srmStatusOfGetRequestResponse *resp = (struct srm2__srmStatusOfGetRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfGetRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmStatusOfGetRequestResponse = resp; _param_18->srmStatusOfGetRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfGet_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfGetRequestRequest *srmStatusOfGetRequest, struct srm2__srmStatusOfGetRequestResponse_ *_param_18) { struct srm2__srmStatusOfGetRequestResponse *resp = (struct srm2__srmStatusOfGetRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfGetRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTGetRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTGetRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TGetRequestFileStatus**) soap_malloc (soap,sizeof (struct srm2__TGetRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TGetRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__TGetRequestFileStatus)); resp->arrayOfFileStatuses->statusArray[0] = NULL; _param_18->srmStatusOfGetRequestResponse = resp; _param_18->srmStatusOfGetRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfGet_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfGetRequestRequest *srmStatusOfGetRequest, struct srm2__srmStatusOfGetRequestResponse_ *_param_18) { struct srm2__srmStatusOfGetRequestResponse *resp = (struct srm2__srmStatusOfGetRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfGetRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; // FAILS _param_18->srmStatusOfGetRequestResponse = resp; _param_18->srmStatusOfGetRequestResponse->remainingTotalRequestTime = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_status_of_get_request_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_status_of_get_request_async) { int i; struct srm_preparetoget_input input; struct srm_preparetoget_output output; struct srmv2_pinfilestatus filestatus; struct srm_context context; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... getbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmStatusOfGetRequest = soap_call_srm2__srmStatusOfGet_test1; result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure 1!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfGetRequest = soap_call_srm2__srmStatusOfGet_test2; result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_QUEUED), "Expected Queued in first call!"); for (i=0;i<15;i++) { result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status == srm_call_status_SUCCESS) || (internal_context.current_status == srm_call_status_FAILURE), "Do not fail/succeed if queued,expected timeout after 10 calls.!"); } fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfGetRequest = soap_call_srm2__srmStatusOfGet_test3; result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; output.filestatuses= &filestatus; call_function.call_srm2__srmStatusOfGetRequest = soap_call_srm2__srmStatusOfGet_test4; result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_SUCCESS) || (result == -1), "Expected Success!"); call_function.call_srm2__srmStatusOfGetRequest = soap_call_srm2__srmStatusOfGet_test5; result = srmv2_status_of_get_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure!"); } END_TEST int soap_call_srm2__srmPrepareToPut_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { _param_18->srmPrepareToPutResponse = NULL; return 0; // success but return statuses are NULL } int soap_call_srm2__srmPrepareToPut_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmBringOnlineRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; retstatus->statusCode = SRM_USCOREFAILURE; retstatus->explanation = NULL; return -1; // failure } int soap_call_srm2__srmPrepareToPut_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; retstatus->statusCode = SRM_USCOREPARTIAL_USCORESUCCESS; retstatus->explanation = NULL; return 0; // success } int soap_call_srm2__srmPrepareToPut_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = NULL; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToPut_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = NULL; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToPut_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->requestToken = fixture_test_string; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmPrepareToPut_test7(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPrepareToPutRequest *srmPrepareToPutRequest, struct srm2__srmPrepareToPutResponse_ *_param_18) { struct srm2__srmPrepareToPutResponse *resp = (struct srm2__srmPrepareToPutResponse *) soap_malloc (soap,sizeof (struct srm2__srmPrepareToPutResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmPrepareToPutResponse = resp; _param_18->srmPrepareToPutResponse->remainingTotalRequestTime = NULL; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTPutRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTPutRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TPutRequestFileStatus**) soap_malloc (soap,sizeof (struct srm2__TPutRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TPutRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__TPutRequestFileStatus)); resp->arrayOfFileStatuses->statusArray[0] = NULL; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_prepare_to_put_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_prepare_to_put_async) { struct srm_preparetoput_input input; struct srm_preparetoput_output output; struct srm_context context; SRM_LONG64 filesizes_test[] = { 1024 }; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.filesizes = filesizes_test; input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... getbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test1; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 1!"); call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test2; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 2!"); call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test3; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 3!"); call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test4; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE)|| (result != -1), "Expected Failure 4!"); call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test5; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT)|| (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test6; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); free(output.token); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued!"); input.filesizes = NULL; call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test7; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure 4!"); input.filesizes = filesizes_test; call_function.call_srm2__srmPrepareToPut = soap_call_srm2__srmPrepareToPut_test7; result = srmv2_prepare_to_put_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS)|| (result == -1), "Expected Success!"); } END_TEST int soap_call_srm2__srmStatusOfPut_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfPutRequestRequest *srmStatusOfPutRequest, struct srm2__srmStatusOfPutRequestResponse_ *_param_18) { _param_18->srmStatusOfPutRequestResponse = NULL; return 0; // success but return statuses are NULL } int soap_call_srm2__srmStatusOfPut_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfPutRequestRequest *srmStatusOfPutRequest, struct srm2__srmStatusOfPutRequestResponse_ *_param_18) { struct srm2__srmStatusOfPutRequestResponse *resp = (struct srm2__srmStatusOfPutRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfPutRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREREQUEST_USCOREQUEUED; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmStatusOfPutRequestResponse = resp; resp->remainingTotalRequestTime = NULL; return 0; // success } int soap_call_srm2__srmStatusOfPut_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfPutRequestRequest *srmStatusOfPutRequest, struct srm2__srmStatusOfPutRequestResponse_ *_param_18) { struct srm2__srmStatusOfPutRequestResponse *resp = (struct srm2__srmStatusOfPutRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfPutRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREINTERNAL_USCOREERROR; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; resp->remainingTotalRequestTime = NULL; _param_18->srmStatusOfPutRequestResponse = resp; return 0; // success } int soap_call_srm2__srmStatusOfPut_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfPutRequestRequest *srmStatusOfPutRequest, struct srm2__srmStatusOfPutRequestResponse_ *_param_18) { struct srm2__srmStatusOfPutRequestResponse *resp = (struct srm2__srmStatusOfPutRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfPutRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->remainingTotalRequestTime = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTPutRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTPutRequestFileStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TPutRequestFileStatus**) soap_malloc (soap,sizeof (struct srm2__TPutRequestFileStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TPutRequestFileStatus*) soap_malloc (soap,sizeof (struct srm2__TPutRequestFileStatus)); resp->arrayOfFileStatuses->statusArray[0] = NULL; _param_18->srmStatusOfPutRequestResponse = resp; return 0; // success } int soap_call_srm2__srmStatusOfPut_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmStatusOfPutRequestRequest *srmStatusOfPutRequest, struct srm2__srmStatusOfPutRequestResponse_ *_param_18) { struct srm2__srmStatusOfPutRequestResponse *resp = (struct srm2__srmStatusOfPutRequestResponse *) soap_malloc (soap,sizeof (struct srm2__srmStatusOfPutRequestResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; // FAILS resp->remainingTotalRequestTime = NULL; _param_18->srmStatusOfPutRequestResponse = resp; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_status_of_put_request_async ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_status_of_put_request_async) { int i; struct srm_preparetoput_input input; struct srm_preparetoput_output output; struct srmv2_pinfilestatus filestatus; struct srm_context context; struct srm_internal_context internal_context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; char *test_protocols[] = {"protocol1","protocol2",NULL}; int result; internal_context.estimated_wait_time = -1; internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbfiles = 1; input.desiredpintime = 1000; input.spacetokendesc = NULL; // TODO test ... putbestspacetoken input.spacetokendesc = "TEST_SPACE_TOKEN_DESC"; input.surls = test_surls; input.protocols = test_protocols; call_function.call_srm2__srmStatusOfPutRequest = soap_call_srm2__srmStatusOfPut_test1; result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure 1!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfPutRequest = soap_call_srm2__srmStatusOfPut_test2; result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_QUEUED)|| (result == -1), "Expected Queued in first call!"); for (i=0;i<15;i++) { result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status == srm_call_status_SUCCESS) || (internal_context.current_status == srm_call_status_FAILURE), "Do not fail/succeed if queued,expected timeout after 10 calls.!"); } fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; call_function.call_srm2__srmStatusOfPutRequest = soap_call_srm2__srmStatusOfPut_test3; result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_TIMEOUT) || (result != -1), "Expected Timeout!"); internal_context.attempt = 1; internal_context.end_time = time(NULL)+10000; output.filestatuses = &filestatus; call_function.call_srm2__srmStatusOfPutRequest = soap_call_srm2__srmStatusOfPut_test4; result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_SUCCESS) || (result == -1), "Expected Success!"); call_function.call_srm2__srmStatusOfPutRequest = soap_call_srm2__srmStatusOfPut_test5; result = srmv2_status_of_put_request_async_internal(&context,&input,&output,&internal_context); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((internal_context.current_status != srm_call_status_FAILURE) || (result != -1), "Expected Failure!"); } END_TEST int soap_call_srm2__srmGetSpaceMetaData_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceMetaDataRequest *srmGetSpaceMetaDataRequest, struct srm2__srmGetSpaceMetaDataResponse_ *_param_18) { struct srm2__srmGetSpaceMetaDataResponse *resp = (struct srm2__srmGetSpaceMetaDataResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceMetaDataResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceDetails = NULL; // FAILS _param_18->srmGetSpaceMetaDataResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceMetaData_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceMetaDataRequest *srmGetSpaceMetaDataRequest, struct srm2__srmGetSpaceMetaDataResponse_ *_param_18) { _param_18->srmGetSpaceMetaDataResponse = NULL; // FAILS return 0; // success } int soap_call_srm2__srmGetSpaceMetaData_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceMetaDataRequest *srmGetSpaceMetaDataRequest, struct srm2__srmGetSpaceMetaDataResponse_ *_param_18) { struct srm2__srmGetSpaceMetaDataResponse *resp = (struct srm2__srmGetSpaceMetaDataResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceMetaDataResponse)); resp->returnStatus = NULL;// FAILS resp->arrayOfSpaceDetails = NULL; _param_18->srmGetSpaceMetaDataResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceMetaData_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceMetaDataRequest *srmGetSpaceMetaDataRequest, struct srm2__srmGetSpaceMetaDataResponse_ *_param_18) { struct srm2__srmGetSpaceMetaDataResponse *resp = (struct srm2__srmGetSpaceMetaDataResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceMetaDataResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceDetails = NULL; _param_18->srmGetSpaceMetaDataResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceMetaData_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceMetaDataRequest *srmGetSpaceMetaDataRequest, struct srm2__srmGetSpaceMetaDataResponse_ *_param_18) { struct srm2__srmGetSpaceMetaDataResponse *resp = (struct srm2__srmGetSpaceMetaDataResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceMetaDataResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceDetails = (struct srm2__ArrayOfTMetaDataSpace*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTMetaDataSpace)); resp->arrayOfSpaceDetails->__sizespaceDataArray = 1; resp->arrayOfSpaceDetails->spaceDataArray = (struct srm2__TMetaDataSpace**) soap_malloc (soap,sizeof (struct srm2__TMetaDataSpace *)); resp->arrayOfSpaceDetails->spaceDataArray[0] = (struct srm2__TMetaDataSpace*) soap_malloc (soap,sizeof (struct srm2__TMetaDataSpace)); resp->arrayOfSpaceDetails->spaceDataArray[0] = NULL; _param_18->srmGetSpaceMetaDataResponse = resp; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_getspacemd ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_getspacemd) { struct srm_getspacemd_input input; struct srm_spacemd *spaces; struct srm_context context; char *test_tokens1[] = {"token1",NULL}; char *test_tokens2[] = {"token1","token2",NULL}; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.nbtokens = 0; input.spacetokens = NULL; call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test1; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); input.nbtokens = 1; input.spacetokens = NULL; call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test1; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); input.nbtokens = 1; // FAILS wrong count input.spacetokens = test_tokens2; call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test1; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); input.nbtokens = 2; call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test1; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test2; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test3; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test4; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != -1), "Expected Failure !"); input.nbtokens = 1; input.spacetokens = test_tokens1; call_function.call_srm2__srmGetSpaceMetaData = soap_call_srm2__srmGetSpaceMetaData_test5; result = srmv2_getspacemd(&context,&input,&spaces); fail_if ((result != 0), "Expected Success!"); } END_TEST int soap_call_srm2__srmGetSpaceTokens_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { struct srm2__srmGetSpaceTokensResponse *resp = (struct srm2__srmGetSpaceTokensResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceTokensResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceTokens = NULL; // FAILS _param_18->srmGetSpaceTokensResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceTokens_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { _param_18->srmGetSpaceTokensResponse = NULL; // FAILS return 0; // success } int soap_call_srm2__srmGetSpaceTokens_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { struct srm2__srmGetSpaceTokensResponse *resp = (struct srm2__srmGetSpaceTokensResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceTokensResponse)); resp->returnStatus = NULL;// FAILS resp->arrayOfSpaceTokens = NULL; _param_18->srmGetSpaceTokensResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceTokens_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { struct srm2__srmGetSpaceTokensResponse *resp = (struct srm2__srmGetSpaceTokensResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceTokensResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceTokens = NULL; _param_18->srmGetSpaceTokensResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceTokens_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { struct srm2__srmGetSpaceTokensResponse *resp = (struct srm2__srmGetSpaceTokensResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetSpaceTokensResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfSpaceTokens = (struct srm2__ArrayOfString*) soap_malloc (soap,sizeof (struct srm2__ArrayOfString)); resp->arrayOfSpaceTokens->__sizestringArray = 1; resp->arrayOfSpaceTokens->stringArray = (char **) soap_malloc (soap,sizeof (char *)); resp->arrayOfSpaceTokens->stringArray[0] = (char *) soap_malloc (soap,sizeof (char)); resp->arrayOfSpaceTokens->stringArray[0] = fixture_test_string; _param_18->srmGetSpaceTokensResponse = resp; return 0; // success } int soap_call_srm2__srmGetSpaceTokens_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetSpaceTokensRequest *srmGetSpaceTokensRequest, struct srm2__srmGetSpaceTokensResponse_ *_param_18) { return -1; // failure } ////////////////////////////////////////////////////////////////// // test test_srmv2_getspacetokens ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_getspacetokens) { struct srm_getspacetokens_input input; struct srm_getspacetokens_output output; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); input.spacetokendesc = NULL; call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test1; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); input.spacetokendesc = "MySpaceTokens"; call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test1; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test2; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test3; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test4; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test5; result = srmv2_getspacetokens(&context,&input,&output); fail_if ((result != 0), "Expected Success!"); fail_if ((strcmp(output.spacetokens[0],fixture_test_string) != 0), "Expected the same string !"); free(output.spacetokens[0]); free(output.spacetokens); call_function.call_srm2__srmGetSpaceTokens = soap_call_srm2__srmGetSpaceTokens_test6; result = srmv2_getspacetokens(&context,&input,&output); free(output.spacetokens); fail_if ((result != -1), "Expected Failure !"); } END_TEST int soap_call_srm2__srmPing_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPingRequest *srmPingRequest, struct srm2__srmPingResponse_ *_param_18) { struct srm2__srmPingResponse *resp = (struct srm2__srmPingResponse *) soap_malloc (soap,sizeof (struct srm2__srmPingResponse)); resp->versionInfo = fixture_test_string; _param_18->srmPingResponse = resp; return 0; // success } int soap_call_srm2__srmPing_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPingRequest *srmPingRequest, struct srm2__srmPingResponse_ *_param_18) { struct srm2__srmPingResponse *resp = (struct srm2__srmPingResponse *) soap_malloc (soap,sizeof (struct srm2__srmPingResponse)); resp->versionInfo = NULL; // FAIL _param_18->srmPingResponse = resp; return 0; } int soap_call_srm2__srmPing_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPingRequest *srmPingRequest, struct srm2__srmPingResponse_ *_param_18) { _param_18->srmPingResponse = NULL; // FAIL return 0; } int soap_call_srm2__srmPing_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmPingRequest *srmPingRequest, struct srm2__srmPingResponse_ *_param_18) { struct srm2__srmPingResponse *resp = (struct srm2__srmPingResponse *) soap_malloc (soap,sizeof (struct srm2__srmPingResponse)); resp->versionInfo = fixture_test_string; _param_18->srmPingResponse = resp; return -1; // fail } ////////////////////////////////////////////////////////////////// // test test_srmv2_ping ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_ping) { struct srm_ping_output output; struct srm_context context; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); call_function.call_srm2__srmPing = soap_call_srm2__srmPing_test1; result = srmv2_ping(&context,&output); free(output.versioninfo); fail_if ((result != 0), "Expected Success !"); call_function.call_srm2__srmPing = soap_call_srm2__srmPing_test2; result = srmv2_ping(&context,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmPing = soap_call_srm2__srmPing_test3; result = srmv2_ping(&context,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmPing = soap_call_srm2__srmPing_test4; result = srmv2_ping(&context,&output); fail_if ((result != -1), "Expected Failure !"); } END_TEST int soap_call_srm2__srmSetPermission_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { struct srm2__srmSetPermissionResponse *resp = (struct srm2__srmSetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmSetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmSetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmSetPermission_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { _param_18->srmSetPermissionResponse = NULL; // FAILS return 0; // success } int soap_call_srm2__srmSetPermission_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { struct srm2__srmSetPermissionResponse *resp = (struct srm2__srmSetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmSetPermissionResponse)); resp->returnStatus = NULL;// FAILS _param_18->srmSetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmSetPermission_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { struct srm2__srmSetPermissionResponse *resp = (struct srm2__srmSetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmSetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmSetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmSetPermission_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { struct srm2__srmSetPermissionResponse *resp = (struct srm2__srmSetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmSetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmSetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmSetPermission_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmSetPermissionRequest *srmSetPermissionRequest, struct srm2__srmSetPermissionResponse_ *_param_18) { return -1; // failure } ////////////////////////////////////////////////////////////////// // test test_srmv2_set_permission ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_set_permission) { struct srm_setpermission_input input; struct srm_permission user_perm; struct srm_context context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); context.version = VERSION_2_2; input.surl = test_surls[0]; input.owner_permission = SRM_PERMISSION_RWX; input.other_permission = SRM_PERMISSION_RW; input.group_permissions_count = 0; input.group_permissions = NULL; user_perm.mode = SRM_PERMISSION_RWX; user_perm.name_id = "tmanev"; input.user_permissions_count = 1; input.user_permissions = &user_perm; input.permission_type = SRM_PERMISSION_ADD; call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test1; result = srmv2_set_permission(&context,&input); fail_if ((result != 0), "Expected Success !"); call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test2; result = srmv2_set_permission(&context,&input); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test3; result = srmv2_set_permission(&context,&input); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test4; result = srmv2_set_permission(&context,&input); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test5; result = srmv2_set_permission(&context,&input); fail_if ((result != 0), "Expected Success!"); call_function.call_srm2__srmSetPermission = soap_call_srm2__srmSetPermission_test6; result = srmv2_set_permission(&context,&input); fail_if ((result != -1), "Expected Failure !"); } END_TEST int soap_call_srm2__srmGetPermission_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { struct srm2__srmGetPermissionResponse *resp = (struct srm2__srmGetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfPermissionReturns = NULL; _param_18->srmGetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmGetPermission_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { _param_18->srmGetPermissionResponse = NULL; // FAILS return 0; // success } int soap_call_srm2__srmGetPermission_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { struct srm2__srmGetPermissionResponse *resp = (struct srm2__srmGetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetPermissionResponse)); resp->returnStatus = NULL;// FAILS resp->arrayOfPermissionReturns = NULL; _param_18->srmGetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmGetPermission_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { struct srm2__srmGetPermissionResponse *resp = (struct srm2__srmGetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfPermissionReturns = NULL; _param_18->srmGetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmGetPermission_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { struct srm2__srmGetPermissionResponse *resp = (struct srm2__srmGetPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmGetPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfPermissionReturns = (struct srm2__ArrayOfTPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTPermissionReturn)); resp->arrayOfPermissionReturns->__sizepermissionArray = 1; resp->arrayOfPermissionReturns->permissionArray = (struct srm2__TPermissionReturn**) soap_malloc (soap,sizeof (struct srm2__TPermissionReturn *)); resp->arrayOfPermissionReturns->permissionArray[0] = (struct srm2__TPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__TPermissionReturn)); resp->arrayOfPermissionReturns->permissionArray[0]->surl = fixture_test_string; resp->arrayOfPermissionReturns->permissionArray[0]->owner = fixture_test_string; resp->arrayOfPermissionReturns->permissionArray[0]->ownerPermission = NULL; resp->arrayOfPermissionReturns->permissionArray[0]->arrayOfGroupPermissions = NULL; resp->arrayOfPermissionReturns->permissionArray[0]->arrayOfUserPermissions = NULL; resp->arrayOfPermissionReturns->permissionArray[0]->otherPermission = NULL; resp->arrayOfPermissionReturns->permissionArray[0]->status = retstatus; _param_18->srmGetPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmGetPermission_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmGetPermissionRequest *srmGetPermissionRequest, struct srm2__srmGetPermissionResponse_ *_param_18) { return -1; // failure } ////////////////////////////////////////////////////////////////// // test test_srmv2_get_permission ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_get_permission) { struct srm_getpermission_input input; struct srm_getpermission_output output; struct srm_context context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); context.version = VERSION_2_2; input.nbfiles = 1; input.surls = test_surls; call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test1; result = srmv2_get_permission(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test2; result = srmv2_get_permission(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test3; result = srmv2_get_permission(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test4; result = srmv2_get_permission(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test5; result = srmv2_get_permission(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != 1), "Expected Success!"); call_function.call_srm2__srmGetPermission = soap_call_srm2__srmGetPermission_test6; result = srmv2_get_permission(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); } END_TEST int soap_call_srm2__srmCheckPermission_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { struct srm2__srmCheckPermissionResponse *resp = (struct srm2__srmCheckPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmCheckPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfPermissions = NULL; _param_18->srmCheckPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmCheckPermission_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { _param_18->srmCheckPermissionResponse = NULL; // FAILS return 0; // success } int soap_call_srm2__srmCheckPermission_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { struct srm2__srmCheckPermissionResponse *resp = (struct srm2__srmCheckPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmCheckPermissionResponse)); resp->returnStatus = NULL;// FAILS resp->arrayOfPermissions = NULL; _param_18->srmCheckPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmCheckPermission_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { struct srm2__srmCheckPermissionResponse *resp = (struct srm2__srmCheckPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmCheckPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfPermissions = NULL; _param_18->srmCheckPermissionResponse = resp; return 0; // success } int soap_call_srm2__srmCheckPermission_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { struct srm2__srmCheckPermissionResponse *resp = (struct srm2__srmCheckPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmCheckPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); enum srm2__TPermissionMode *cur_permission = (enum srm2__TPermissionMode *) soap_malloc (soap,sizeof (enum srm2__TPermissionMode));; retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmCheckPermissionResponse = resp; *cur_permission = RWX; resp->arrayOfPermissions = (struct srm2__ArrayOfTSURLPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLPermissionReturn)); resp->arrayOfPermissions->__sizesurlPermissionArray = 1; resp->arrayOfPermissions->surlPermissionArray = (struct srm2__TSURLPermissionReturn**) soap_malloc (soap,sizeof (struct srm2__TSURLPermissionReturn *)); resp->arrayOfPermissions->surlPermissionArray[0] = (struct srm2__TSURLPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__TSURLPermissionReturn)); resp->arrayOfPermissions->surlPermissionArray[0]->surl = fixture_test_string; resp->arrayOfPermissions->surlPermissionArray[0]->permission = cur_permission; resp->arrayOfPermissions->surlPermissionArray[0]->status = retstatus; return 0; // success } int soap_call_srm2__srmCheckPermission_test6(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmCheckPermissionRequest *srmCheckPermissionRequest, struct srm2__srmCheckPermissionResponse_ *_param_18) { struct srm2__srmCheckPermissionResponse *resp = (struct srm2__srmCheckPermissionResponse *) soap_malloc (soap,sizeof (struct srm2__srmCheckPermissionResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); enum srm2__TPermissionMode *cur_permission = (enum srm2__TPermissionMode *) soap_malloc (soap,sizeof (enum srm2__TPermissionMode));; retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmCheckPermissionResponse = resp; *cur_permission = WX; resp->arrayOfPermissions = (struct srm2__ArrayOfTSURLPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLPermissionReturn)); resp->arrayOfPermissions->__sizesurlPermissionArray = 1; resp->arrayOfPermissions->surlPermissionArray = (struct srm2__TSURLPermissionReturn**) soap_malloc (soap,sizeof (struct srm2__TSURLPermissionReturn *)); resp->arrayOfPermissions->surlPermissionArray[0] = (struct srm2__TSURLPermissionReturn*) soap_malloc (soap,sizeof (struct srm2__TSURLPermissionReturn)); resp->arrayOfPermissions->surlPermissionArray[0]->surl = fixture_test_string; resp->arrayOfPermissions->surlPermissionArray[0]->permission = cur_permission; resp->arrayOfPermissions->surlPermissionArray[0]->status = retstatus; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_check_permission ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_check_permission) { struct srm_checkpermission_input input; struct srmv2_filestatus *status; struct srm_context context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); context.version = VERSION_2_2; input.amode = R_OK; input.nbfiles = 1; input.surls = test_surls; call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test1; result = srmv2_check_permission(&context,&input,&status); //failure empty fs fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test2; result = srmv2_check_permission(&context,&input,&status); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test3; result = srmv2_check_permission(&context,&input,&status); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test4; result = srmv2_check_permission(&context,&input,&status); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test5; result = srmv2_check_permission(&context,&input,&status); fail_if ((result != 1), "Expected Success!"); fail_if ((status[0].status != 0), "Expected Status 0!"); call_function.call_srm2__srmCheckPermission = soap_call_srm2__srmCheckPermission_test6; result = srmv2_check_permission(&context,&input,&status); fail_if ((result != 1), "Expected Success!"); fail_if ((status[0].status == 0), "Expected Status EACCESS!"); } END_TEST int soap_call_srm2__srmExtendFileLifeTime_test1(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmExtendFileLifeTimeRequest *srmExtendFileLifeTimeRequest, struct srm2__srmExtendFileLifeTimeResponse_ *_param_18) { struct srm2__srmExtendFileLifeTimeResponse *resp = (struct srm2__srmExtendFileLifeTimeResponse *) soap_malloc (soap,sizeof (struct srm2__srmExtendFileLifeTimeResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCORESUCCESS; retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmExtendFileLifeTimeResponse = resp; return 0; // success } int soap_call_srm2__srmExtendFileLifeTime_test2(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmExtendFileLifeTimeRequest *srmExtendFileLifeTimeRequest, struct srm2__srmExtendFileLifeTimeResponse_ *_param_18) { //struct srm2__srmExtendFileLifeTimeResponse *resp = (struct srm2__srmExtendFileLifeTimeResponse *) soap_malloc (soap,sizeof (struct srm2__srmExtendFileLifeTimeResponse)); _param_18->srmExtendFileLifeTimeResponse = NULL; // FAILS //resp->arrayOfFileStatuses = NULL; //resp->returnStatus = NULL; return 0; // success } int soap_call_srm2__srmExtendFileLifeTime_test3(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmExtendFileLifeTimeRequest *srmExtendFileLifeTimeRequest, struct srm2__srmExtendFileLifeTimeResponse_ *_param_18) { struct srm2__srmExtendFileLifeTimeResponse *resp = (struct srm2__srmExtendFileLifeTimeResponse *) soap_malloc (soap,sizeof (struct srm2__srmExtendFileLifeTimeResponse)); resp->returnStatus = NULL;// FAILS resp->arrayOfFileStatuses = NULL; _param_18->srmExtendFileLifeTimeResponse = resp; return 0; // success } int soap_call_srm2__srmExtendFileLifeTime_test4(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmExtendFileLifeTimeRequest *srmExtendFileLifeTimeRequest, struct srm2__srmExtendFileLifeTimeResponse_ *_param_18) { struct srm2__srmExtendFileLifeTimeResponse *resp = (struct srm2__srmExtendFileLifeTimeResponse *) soap_malloc (soap,sizeof (struct srm2__srmExtendFileLifeTimeResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); retstatus->statusCode = SRM_USCOREFAILURE; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; resp->arrayOfFileStatuses = NULL; _param_18->srmExtendFileLifeTimeResponse = resp; return 0; // success } int soap_call_srm2__srmExtendFileLifeTime_test5(struct soap *soap, const char *soap_endpoint, const char *soap_action, struct srm2__srmExtendFileLifeTimeRequest *srmExtendFileLifeTimeRequest, struct srm2__srmExtendFileLifeTimeResponse_ *_param_18) { struct srm2__srmExtendFileLifeTimeResponse *resp = (struct srm2__srmExtendFileLifeTimeResponse *) soap_malloc (soap,sizeof (struct srm2__srmExtendFileLifeTimeResponse)); struct srm2__TReturnStatus *retstatus = (struct srm2__TReturnStatus *) soap_malloc (soap,sizeof (struct srm2__TReturnStatus)); int *pinlifetime = (int *) soap_malloc (soap,sizeof (int)); retstatus->statusCode = SRM_USCORESUCCESS; // FAILS retstatus->explanation = NULL; resp->returnStatus = retstatus; _param_18->srmExtendFileLifeTimeResponse = resp; *pinlifetime = 100; resp->arrayOfFileStatuses = (struct srm2__ArrayOfTSURLLifetimeReturnStatus*) soap_malloc (soap,sizeof (struct srm2__ArrayOfTSURLLifetimeReturnStatus)); resp->arrayOfFileStatuses->__sizestatusArray = 1; resp->arrayOfFileStatuses->statusArray = (struct srm2__TSURLLifetimeReturnStatus**) soap_malloc (soap,sizeof (struct srm2__TSURLLifetimeReturnStatus *)); resp->arrayOfFileStatuses->statusArray[0] = (struct srm2__TSURLLifetimeReturnStatus*) soap_malloc (soap,sizeof (struct srm2__TSURLLifetimeReturnStatus)); resp->arrayOfFileStatuses->statusArray[0]->surl = fixture_test_string; resp->arrayOfFileStatuses->statusArray[0]->fileLifetime = pinlifetime; resp->arrayOfFileStatuses->statusArray[0]->pinLifetime = pinlifetime; resp->arrayOfFileStatuses->statusArray[0]->status = retstatus; return 0; // success } ////////////////////////////////////////////////////////////////// // test test_srmv2_extend_file_lifetime ////////////////////////////////////////////////////////////////// START_TEST (test_srmv2_extend_file_lifetime) { struct srm_extendfilelifetime_input input; struct srm_extendfilelifetime_output output; struct srm_context context; char *test_surls[] = {"srm://lxbra1910.cern.ch:8446/srm/managerv2?SFN=/dpm/cern.ch/home/dteam/"}; int result; call_function.call_sleep = mock_sleep; // set mock sleep function srm_context_init(&context, "test", NULL, 0, 0); context.version = VERSION_2_2; input.pintime = 100; input.nbfiles = 1; input.surls = test_surls; input.reqtoken = "test"; call_function.call_srm2__srmExtendFileLifeTime = soap_call_srm2__srmExtendFileLifeTime_test1; result = srmv2_extend_file_lifetime(&context,&input,&output); //failure empty fs srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmExtendFileLifeTime = soap_call_srm2__srmExtendFileLifeTime_test2; result = srmv2_extend_file_lifetime(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmExtendFileLifeTime = soap_call_srm2__srmExtendFileLifeTime_test3; result = srmv2_extend_file_lifetime(&context,&input,&output); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmExtendFileLifeTime = soap_call_srm2__srmExtendFileLifeTime_test4; result = srmv2_extend_file_lifetime(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != -1), "Expected Failure !"); call_function.call_srm2__srmExtendFileLifeTime = soap_call_srm2__srmExtendFileLifeTime_test5; result = srmv2_extend_file_lifetime(&context,&input,&output); srm_srm2__TReturnStatus_delete(output.retstatus); fail_if ((result != 1), "Expected Success!"); } END_TEST START_TEST (test_srm_util_add_strings) { const char* s1 = "s1"; const char* s2 = "s2"; char* res = NULL; res = srm_util_add_strings(s1, s2); fail_unless(strcmp("s1s2", res) == 0, "Expected equality"); free(res); res = NULL; res = srm_util_add_strings("", s2); fail_unless(strcmp(s2, res) == 0, "Expected equality"); free(res); res = NULL; res = srm_util_add_strings(s1, ""); fail_unless(strcmp(s1, res) == 0, "Expected equality"); free(res); res = NULL; res = srm_util_add_strings("", ""); fail_unless(strcmp("", res) == 0, "Expected equality"); free(res); res = NULL; } END_TEST START_TEST (test_srm_util_consolidate_multiple_characters) { char* res = NULL; fail_unless(NULL == srm_util_consolidate_multiple_characters(NULL, 'x', 0)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("abcd", 'a', 0); fail_unless(0 == strcmp("abcd", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("abcd", 'x', 0); fail_unless(0 == strcmp("abcd", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("abcd", '0', 0); fail_unless(0 == strcmp("abcd", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("", '0', 0); fail_unless(0 == strcmp("", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("", 'a', 0); fail_unless(0 == strcmp("", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("a", 'a', 0); fail_unless(0 == strcmp("a", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aa", 'a', 0); fail_unless(0 == strcmp("a", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaa", 'a', 0); fail_unless(0 == strcmp("a", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaa", 'x', 0); fail_unless(0 == strcmp("aaa", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("xaaa", 'a', 0); fail_unless(0 == strcmp("xa", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("xaaay", 'a', 0); fail_unless(0 == strcmp("xay", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaay", 'a', 0); fail_unless(0 == strcmp("ay", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaaxaaay", 'a', 3); fail_unless(0 == strcmp("aaaxay", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaaxaaay", 'a', 1); fail_unless(0 == strcmp("aaxay", res)); free(res); res = NULL; res = srm_util_consolidate_multiple_characters("aaaxaaay", 'a', 100); fail_unless(0 == strcmp("aaaxaaay", res)); free(res); res = NULL; } END_TEST START_TEST (test_srm_util_normalize_surl) { char* surl_1 = "srm://server:port/"; char* surl_2 = "srm://server:port/dir1"; char* surl_3 = "srm://server:port/dir1/"; char* surl_4 = "srm://server:port/dir1//"; char* surl_5 = "srm://server:port/dir1/dir2/"; char* surl_6 = "srm://server:port/dir1/dir2"; char* surl_7 = "srm://server:port/dir1//dir2/"; char* surl_8 = "srm://server:port/dir1//dir2//"; char* res = NULL; res = srm_util_normalize_surl(surl_1); fail_unless(strcmp(surl_1, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_2); fail_unless(strcmp(surl_3, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_3); fail_unless(strcmp(surl_3, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_4); fail_unless(strcmp(surl_3, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_5); fail_unless(strcmp(surl_5, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_6); fail_unless(strcmp(surl_5, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_7); fail_unless(strcmp(surl_5, res) == 0); free(res); res = NULL; res = srm_util_normalize_surl(surl_8); fail_unless(strcmp(surl_5, res) == 0); free(res); res = NULL; } END_TEST START_TEST (test_srmv2_check_srm_root) { const char* good_url = "srm://server.cern.ch/"; const char* bad_url_1 = "srm://server.cern.ch/file"; const char* bad_url_2 = "fake://server.cern.ch/file"; const char* bad_url_3 = "srm:/server.cern.ch/file"; const char* bad_url_4 = "srm//server.cern.ch/file"; const char* bad_url_5 = "srm://server.cern.ch"; fail_unless(1 == srmv2_check_srm_root(good_url)); fail_unless(0 == srmv2_check_srm_root(NULL)); fail_unless(0 == srmv2_check_srm_root(bad_url_1)); fail_unless(0 == srmv2_check_srm_root(bad_url_2)); fail_unless(0 == srmv2_check_srm_root(bad_url_3)); fail_unless(0 == srmv2_check_srm_root(bad_url_4)); fail_unless(0 == srmv2_check_srm_root(bad_url_5)); } END_TEST START_TEST (test_srm_context) { char errbuff[200]; struct srm_context old_style; srm_context_init(&old_style,"my_endpoint", errbuff,200,1); srm_context_t c = srm_context_new("my_endpoint",errbuff,200,1); srm_context_free(c); c = NULL; srm_context_free(c); srm_context_free(&old_style); } END_TEST Suite * test_suite (void) { Suite *s = suite_create ("new srm interface unit test suit"); gfal_unittest_srmls_test_suite(s); TCase *tc_case_1 = tcase_create ("srm function tests"); tcase_add_checked_fixture (tc_case_1, NULL,NULL); tcase_add_test (tc_case_1, test_srmv2_extend_file_lifetime); tcase_add_test (tc_case_1, test_srmv2_set_permission); tcase_add_test (tc_case_1, test_srmv2_get_permission); tcase_add_test (tc_case_1, test_srmv2_check_permission); tcase_add_test (tc_case_1, test_wait_for_new_attempt); tcase_add_test (tc_case_1, test_back_off_logic); tcase_add_test (tc_case_1, test_srmv2_abort_request); tcase_add_test (tc_case_1, test_srmv2_rmdir); tcase_add_test (tc_case_1, test_srmv2_rm); tcase_add_test (tc_case_1, test_srmv2_mkdir); tcase_add_test (tc_case_1, test_srmv2_abort_files); tcase_add_test (tc_case_1, test_srmv2_put_done); tcase_add_test (tc_case_1, test_srmv2_release_files); tcase_add_test (tc_case_1, test_srmv2_bring_online_async); tcase_add_test (tc_case_1, test_srmv2_status_of_bring_online_async); tcase_add_test (tc_case_1, test_srmv2_prepare_to_get_async); tcase_add_test (tc_case_1, test_srmv2_status_of_get_request_async); tcase_add_test (tc_case_1, test_srmv2_prepare_to_put_async); tcase_add_test (tc_case_1, test_srmv2_status_of_put_request_async); tcase_add_test (tc_case_1, test_srmv2_getspacemd); tcase_add_test (tc_case_1, test_srmv2_getspacetokens); tcase_add_test (tc_case_1, test_srmv2_ping); suite_add_tcase (s, tc_case_1); TCase *tc_case_2 = tcase_create ("utility function tests"); tcase_add_checked_fixture (tc_case_2, NULL,NULL); tcase_add_test (tc_case_2, test_srm_util_add_strings); tcase_add_test (tc_case_2, test_srm_util_normalize_surl); tcase_add_test (tc_case_2, test_srm_util_consolidate_multiple_characters); tcase_add_test (tc_case_2, test_srmv2_check_srm_root); tcase_add_test (tc_case_2, test_srm_context); tcase_add_test (tc_case_2, test_wait_ng); suite_add_tcase (s, tc_case_2); return s; } int main(void) { int number_failed; Suite *s = test_suite (); SRunner *sr = srunner_create (s); srunner_set_fork_status (sr, CK_NOFORK); // for easier debug srunner_run_all (sr, CK_VERBOSE); number_failed = srunner_ntests_failed (sr); srunner_free (sr); return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; } srm-ifce-1.18.0/src/gfal_srm_ifce_unittest_common.c0000644001662700052000000000165512217066060021331 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "gfal_srm_ifce_unittest.h" unsigned int mock_sleep_time = 0; char fixture_test_string[] = "test_string"; unsigned int mock_sleep(unsigned int time) { mock_sleep_time = time; return 0; } srm-ifce-1.18.0/src/srm_util.h0000644001662700052000000001377012217066060015106 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #ifndef SRM_UTIL_H_ #define SRM_UTIL_H_ #include "time_utils.h" //static allocation void srm_soap_init(struct soap *soap); void srm_soap_deinit(struct soap *soap); // dyn allocation /** dynamic allocation of a srm soap context timeouts are initialized from the default values */ struct soap * srm_soap_init_new(); /** dynamic allocation of a srm soap context timeouts are initialized from the context values ( default, excepted if user-change */ struct soap * srm_soap_init_context_new(struct srm_context* c); /** free an srm gsoap context */ void srm_soap_free(struct soap *soap); void srm_print_explanation(char **explanation,struct srm2__TReturnStatus *reqstatp,const char *srmfunc); extern const char *err_msg_begin; void srm_errmsg (struct srm_context *context, const char *format, ...); int srm_soap_call_err(struct srm_context *context,struct soap *soap,const char *srmfunc); int srm_call_err(struct srm_context *context,struct srm2__TReturnStatus *retstatus,const char *srmfunc); int srm_print_error_status(struct srm_context *context,struct srm2__TReturnStatus *status,const char *srmfunc); int srm_print_error_status_additional(struct srm_context *context,struct srm2__TReturnStatus *status,const char *srmfunc,char *additional_info); int statuscode2errno (int statuscode); const char * statuscode2errmsg (unsigned int statuscode); void back_off_logic_init(struct srm_context *context,struct srm_internal_context *internal_context); srm_call_status back_off_logic(struct srm_context *context,const char *srmfunc, struct srm_internal_context *internal_context,struct srm2__TReturnStatus *retstatus); int wait_for_new_attempt(struct srm_internal_context *internal_context); void srm_spacemd_free (int nbtokens, struct srm_spacemd *smd); int srm_set_protocol_in_transferParameters( struct srm_context *context, struct soap* soap, struct srm2__TTransferParameters* transferParameters, char** protocols); char* srm_strip_string(const char* str, const char chr); int srm_count_elements_of_string_array(char** a); int copy_string(char **dest,char *src); int copy_permissionfilestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_filestatus **statuses, struct srm2__ArrayOfTSURLPermissionReturn *repfs, const char *srmfunc, int amode); int copy_filestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_filestatus **statuses, struct srm2__ArrayOfTSURLReturnStatus *repfs, const char *srmfunc); int copy_pinfilestatuses_extendlifetime(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTSURLLifetimeReturnStatus *repfs, const char *srmfunc); int copy_pinfilestatuses_get(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTGetRequestFileStatus *repfs, const char *srmfunc); int copy_pinfilestatuses_put(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTPutRequestFileStatus *repfs, const char *srmfunc); int copy_pinfilestatuses_bringonline(struct srm2__TReturnStatus *reqstatp, struct srmv2_pinfilestatus **filestatuses, struct srm2__ArrayOfTBringOnlineRequestFileStatus *repfs, const char *srmfunc); int copy_mdfilestatuses(struct srm2__TReturnStatus *reqstatp, struct srmv2_mdfilestatus **statuses, struct srm2__ArrayOfTMetaDataPathDetail *repfs); int copy_returnstatus(struct srm2__TReturnStatus **destination, struct srm2__TReturnStatus *returnStatus); int copy_filepermissions(struct srm2__TReturnStatus *reqstatp, struct srm_filepermission **permissions, struct srm2__ArrayOfTPermissionReturn *repperm); void set_estimated_wait_time(struct srm_internal_context *internal_context, int time); int wait_for_new_attempt_min_max_ng(srm_context_t context, struct srm_internal_context *internal_context); int wait_switch_auto(srm_context_t context, struct srm_internal_context *internal_context); /* General utility functions */ /** * Normalize a SURL: remove multiple slashes (exept for "srm://"), and add a single slash * to the end of the SURL. For example, SURL * * srm://server:port/dir1//dir2 * * will be * * srm://server:port/dir1/dir2/ * * @param surl The SURL to be normalized * * @return The dyamically allocated normalized SURL. */ char* srm_util_normalize_surl(const char* surl); /** * Remove multiple, subsequent characters from a string. For instance: * * srm_util_consolidate_multiple_characters("charrrrrstring, 'r'); * * returns "charstring". * * The returned string is dynamically allocated, free it! * * @param s the string to be consolidated. * @param c the character to look for * @param start consolidating starts from this index. Before this index, all the characters * are copied. * * @return the consolidated string, dynamically allocated, or NULL if s was NULL. */ char* srm_util_consolidate_multiple_characters(const char* s, const char c, const int start); /** * Add (concatenate) two strings into a dynamically allocated new string. * * @param s1 First string * @param s2 Second string (will be added after s2) * * @return The dynamically allocated concatenation. */ char* srm_util_add_strings(const char* s1, const char* s2); #endif /* SRM_UTIL_H_ */ srm-ifce-1.18.0/src/srm_soap.h0000644001662700052000000000156512217066060015072 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #ifndef NEW_SRM_SOAP_H_ #define NEW_SRM_SOAP_H_ #include "srm_dependencies.h" #include "gfal_srm_ifce_types.h" #endif /* NEW_SRM_SOAP_H_ */ srm-ifce-1.18.0/src/srmSoapBinding.c0000644001662700052000000000250512217066060016154 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srmv2H.h" SOAP_NMAC struct Namespace namespaces_srmv2[] = { {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/", "http://www.w3.org/*/soap-envelope", NULL}, {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/", "http://www.w3.org/*/soap-encoding", NULL}, {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance", NULL}, {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema", NULL}, {"srm2", "http://srm.lbl.gov/StorageResourceManager", NULL, NULL}, {NULL, NULL, NULL, NULL} }; struct Namespace namespaces[] ={{NULL, NULL}}; srm-ifce-1.18.0/src/gfal_srm_ifce_unittest.h0000644001662700052000000000224312217066060017760 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Zsolt Molnar, CERN */ #ifndef _GFAL_SRM_IFCE_UNITTEST_H_ #define _GFAL_SRM_IFCE_UNITTEST_H_ #include #include "srm_dependencies.h" #include "gfal_srm_ifce.h" /* Test functions */ extern void gfal_unittest_srmls_test_suite (Suite *s); /* Mock functions */ extern unsigned int mock_sleep(unsigned int time); /* Fixtures */ extern char fixture_test_string[]; /* Global properties */ extern unsigned int mock_sleep_time; #endif /* _GFAL_SRM_IFCE_UNITTEST_H */ srm-ifce-1.18.0/src/srm_dependencies.c0000644001662700052000000000342712217066060016550 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #include "srm_dependencies.h" #include "srm_soap.h" callers_t call_function = { soap_call_srm2__srmPurgeFromSpace, soap_call_srm2__srmExtendFileLifeTime, soap_call_srm2__srmCheckPermission, soap_call_srm2__srmReleaseSpace, soap_call_srm2__srmReserveSpace, soap_call_srm2__srmStatusOfReserveSpaceRequest, soap_call_srm2__srmSetPermission, soap_call_srm2__srmGetPermission, soap_call_srm2__srmPing, soap_call_srm2__srmAbortFiles, soap_call_srm2__srmPutDone, soap_call_srm2__srmReleaseFiles, soap_call_srm2__srmStatusOfGetRequest, soap_call_srm2__srmStatusOfBringOnlineRequest, soap_call_srm2__srmStatusOfPutRequest, soap_call_srm2__srmPrepareToGet, soap_call_srm2__srmBringOnline, soap_call_srm2__srmPrepareToPut, soap_call_srm2__srmGetSpaceMetaData, soap_call_srm2__srmGetSpaceTokens, soap_call_srm2__srmLs, soap_call_srm2__srmStatusOfLsRequest, soap_call_srm2__srmAbortRequest, soap_call_srm2__srmRm, soap_call_srm2__srmRmdir, soap_call_srm2__srmMkdir, soap_call_srm2__srmMv, sleep, usleep }; srm-ifce-1.18.0/src/srm_dependencies.h0000644001662700052000000002025712217066060016555 0ustar adevresscg/* * Copyright (c) Members of the EGEE Collaboration. 2010. * See http://www.eu-egee.org/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. * * Authors: Todor Manev IT-GT CERN */ #ifndef SRM_DEPENDANCIES_H_ #define SRM_DEPENDANCIES_H_ #define WITH_NOGLOBAL #include "stdsoap2.h" /*#undef SOAP_FMAC3 #define SOAP_FMAC3 static #undef SOAP_FMAC5 #define SOAP_FMAC5 static*/ #include "srmv2H.h" #ifdef GFAL_SECURE #include "cgsi_plugin.h" #endif // #ifdef GFAL_SECURE extern struct Namespace namespaces_srmv2[]; /* Function types of the appropriate SOAP calls */ typedef int (*soap_call_srm2__srmGetSpaceMetaData_fv)( struct soap *, const char *, const char *, struct srm2__srmGetSpaceMetaDataRequest *, struct srm2__srmGetSpaceMetaDataResponse_ *); typedef int (*soap_call_srm2__srmGetSpaceTokens_fv)( struct soap *, const char *, const char *, struct srm2__srmGetSpaceTokensRequest *, struct srm2__srmGetSpaceTokensResponse_ *); typedef int (*soap_call_srm2__srmLs_fv)( struct soap *, const char *, const char *, struct srm2__srmLsRequest *, struct srm2__srmLsResponse_ *); typedef int (*soap_call_srm2__srmStatusOfLsRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmStatusOfLsRequestRequest *, struct srm2__srmStatusOfLsRequestResponse_ *); typedef int (*soap_call_srm2__srmAbortRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmAbortRequestRequest *, struct srm2__srmAbortRequestResponse_ *); typedef int (*soap_call_srm2__srmRm_fv)( struct soap *, const char *, const char *, struct srm2__srmRmRequest *, struct srm2__srmRmResponse_ *); typedef int (*soap_call_srm2__srmRmdir_fv)( struct soap *, const char *, const char *, struct srm2__srmRmdirRequest *, struct srm2__srmRmdirResponse_ *); typedef int (*soap_call_srm2__srmMkdir_fv)( struct soap *, const char *, const char *, struct srm2__srmMkdirRequest *, struct srm2__srmMkdirResponse_ *); typedef int (*soap_call_srm2__srmPrepareToGet_fv)( struct soap *, const char *, const char *, struct srm2__srmPrepareToGetRequest *, struct srm2__srmPrepareToGetResponse_ *); typedef int (*soap_call_srm2__srmBringOnline_fv)( struct soap *, const char *, const char *, struct srm2__srmBringOnlineRequest *, struct srm2__srmBringOnlineResponse_ *); typedef int (*soap_call_srm2__srmPrepareToPut_fv)( struct soap *, const char *, const char *, struct srm2__srmPrepareToPutRequest *, struct srm2__srmPrepareToPutResponse_ *); typedef int (*soap_call_srm2__srmStatusOfPutRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmStatusOfPutRequestRequest *, struct srm2__srmStatusOfPutRequestResponse_ *); typedef int (*soap_call_srm2__srmStatusOfBringOnlineRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmStatusOfBringOnlineRequestRequest *, struct srm2__srmStatusOfBringOnlineRequestResponse_ *); typedef int (*soap_call_srm2__srmStatusOfGetRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmStatusOfGetRequestRequest *, struct srm2__srmStatusOfGetRequestResponse_ *); typedef int (*soap_call_srm2__srmPutDone_fv)( struct soap *, const char *, const char *, struct srm2__srmPutDoneRequest*, struct srm2__srmPutDoneResponse_ *); typedef int (*soap_call_srm2__srmReleaseFiles_fv)( struct soap *, const char *, const char *, struct srm2__srmReleaseFilesRequest*, struct srm2__srmReleaseFilesResponse_ *); typedef int (*soap_call_srm2__srmAbortFiles_fv)( struct soap *, const char *, const char *, struct srm2__srmAbortFilesRequest *, struct srm2__srmAbortFilesResponse_ *); typedef int (*soap_call_srm2__srmPing_fv)( struct soap *, const char *, const char *, struct srm2__srmPingRequest *, struct srm2__srmPingResponse_ *); typedef int (*soap_call_srm2__srmSetPermission_fv)( struct soap *, const char *, const char *, struct srm2__srmSetPermissionRequest *, struct srm2__srmSetPermissionResponse_ *); typedef int (*soap_call_srm2__srmGetPermission_fv)( struct soap *, const char *, const char *, struct srm2__srmGetPermissionRequest *, struct srm2__srmGetPermissionResponse_ *); typedef int (*soap_call_srm2__srmReserveSpace_fv)( struct soap *, const char *, const char *, struct srm2__srmReserveSpaceRequest *, struct srm2__srmReserveSpaceResponse_ *); typedef int (*soap_call_srm2__srmStatusOfReserveSpaceRequest_fv)( struct soap *, const char *, const char *, struct srm2__srmStatusOfReserveSpaceRequestRequest *, struct srm2__srmStatusOfReserveSpaceRequestResponse_ *); typedef int (*soap_call_srm2__srmReleaseSpace_fv)( struct soap *, const char *, const char *, struct srm2__srmReleaseSpaceRequest *, struct srm2__srmReleaseSpaceResponse_ *); typedef int (*soap_call_srm2__srmCheckPermission_fv)( struct soap *, const char *, const char *, struct srm2__srmCheckPermissionRequest *, struct srm2__srmCheckPermissionResponse_ *); typedef int (*soap_call_srm2__srmExtendFileLifeTime_fv)( struct soap *, const char *, const char *, struct srm2__srmExtendFileLifeTimeRequest *, struct srm2__srmExtendFileLifeTimeResponse_ *); typedef int (*soap_call_srm2__srmPurgeFromSpace_fv)( struct soap *, const char *, const char *, struct srm2__srmPurgeFromSpaceRequest *, struct srm2__srmPurgeFromSpaceResponse_ *); typedef int (*soap_call_srm2__srmMv_fv)( struct soap *, const char*, const char*, struct srm2__srmMvRequest*, struct srm2__srmMvResponse_*); typedef unsigned int (*sleep_fv)( unsigned int); /* The collection of SOAP service calls. The pointers may be replaced with test * functions (dependency injection) */ typedef struct misc_callers { soap_call_srm2__srmPurgeFromSpace_fv call_srm2__srmPurgeFromSpace; soap_call_srm2__srmExtendFileLifeTime_fv call_srm2__srmExtendFileLifeTime; soap_call_srm2__srmCheckPermission_fv call_srm2__srmCheckPermission; soap_call_srm2__srmReleaseSpace_fv call_srm2__srmReleaseSpace; soap_call_srm2__srmReserveSpace_fv call_srm2__srmReserveSpace; soap_call_srm2__srmStatusOfReserveSpaceRequest_fv call_srm2__srmStatusOfReserveSpaceRequest; soap_call_srm2__srmSetPermission_fv call_srm2__srmSetPermission; soap_call_srm2__srmGetPermission_fv call_srm2__srmGetPermission; soap_call_srm2__srmPing_fv call_srm2__srmPing; soap_call_srm2__srmAbortFiles_fv call_srm2__srmAbortFiles; soap_call_srm2__srmPutDone_fv call_srm2__srmPutDone; soap_call_srm2__srmReleaseFiles_fv call_srm2__srmReleaseFiles; soap_call_srm2__srmStatusOfGetRequest_fv call_srm2__srmStatusOfGetRequest; soap_call_srm2__srmStatusOfBringOnlineRequest_fv call_srm2__srmStatusOfBringOnlineRequest; soap_call_srm2__srmStatusOfPutRequest_fv call_srm2__srmStatusOfPutRequest; soap_call_srm2__srmPrepareToGet_fv call_srm2__srmPrepareToGet; soap_call_srm2__srmBringOnline_fv call_srm2__srmBringOnline; soap_call_srm2__srmPrepareToPut_fv call_srm2__srmPrepareToPut; soap_call_srm2__srmGetSpaceMetaData_fv call_srm2__srmGetSpaceMetaData; soap_call_srm2__srmGetSpaceTokens_fv call_srm2__srmGetSpaceTokens; soap_call_srm2__srmLs_fv call_srm2__srmLs; soap_call_srm2__srmStatusOfLsRequest_fv call_srm2__srmStatusOfLsRequest; soap_call_srm2__srmAbortRequest_fv call_srm2__srmAbortRequest; soap_call_srm2__srmRm_fv call_srm2__srmRm; soap_call_srm2__srmRmdir_fv call_srm2__srmRmdir; soap_call_srm2__srmMkdir_fv call_srm2__srmMkdir; soap_call_srm2__srmMv_fv call_srm2__srmMv; sleep_fv call_sleep; int (*call_usleep)(useconds_t usec); } callers_t; extern callers_t call_function; #endif /* SRM_DEPENDANCIES_H_ */ srm-ifce-1.18.0/LICENSE0000644001662700052000000000123312217066060013304 0ustar adevresscgCopyright (c) Members of the EGEE Collaboration. 2004. See http://www.eu-egee.org/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. srm-ifce-1.18.0/VERSION0000644001662700052000000000003112217066060013342 0ustar adevresscgVERSION=1.15.1 RELEASE=1 srm-ifce-1.18.0/SRPMS/0000755001662700052000000000000012217066060013204 5ustar adevresscgsrm-ifce-1.18.0/RELEASE-NOTES0000644001662700052000000006153412217066060014202 0ustar adevresscg* Fri Sep 20 2013 Adrien Devresse - 1.18.0-1 : - support for mtime and atime st field * Mon Aug 19 2013 Alejandro Alvarez - 1.17.0 : - [LCGUTIL-198] - SRM-ifce : IPv6 flag enabled - [LCGUTIL-203] - GFAL 2.0 : dCache production servers does not return the correct SRM error in case of file already exist. - [LCGUTIL-204] - SRM-ifce : potential security issue allowing arbitrary RAM read - [LCGUTIL-205] - SRM-ifce : globus openssl used indirectly by CGSI_GSOAP override errno values in some case by gsoap_free - [LCGUTIL-206] - GFAL2, SRM-ifce, LCGUTIL, FTS 3.0 : Checksum request are invalid with Storm which answer with MD5 checksum instead of ADLER32 * Tue Jul 02 2013 Adrien Devresse - 1.16.0-0 - [LCGUTIL-90] - SRM-ifce : correct portability issue reported by Mattias - [LCGUTIL-178] - source-contains-unsafe-symlink - [LCGUTIL-183] - SRM-ifce : big cleaning operation done by Michail from coverity scan - [LCGUTIL-184] - SRM-ifce : add srm-mv support for "rename" operation - [LCGUTIL-185] - SRM-ifce : memory leaks correction - [LCGUTIL-186] - Srm-ifce : new session re-use logic in srm-ifce * Tue Jan 08 2013 Adrien Devresse - 1.14.0-1 - correct two timeout bug LCGUTIL-78 and LCGUTIL-82 * Thu Nov 29 2012 Adrien Devresse - 1.14.0-0 - correct misleading namespace in PrepareToGetRequestStatus - correct a timeout issue related to exponential backoff system in put/get - improve reliability of the exponential backoff wait system - big big code cleaning - re-factory of the context system with backward compatibility - fix the srm timeout issue - fix the srm put done issue for long transfer Fri Jul 20 2012 Adrien Devresse - 1.13.0-0 - Synchronise with EMI 2 Update 13 - introduction of operation timeout - buffer overflow and memory corruption corrections - minor warning corrections - ABI break, extend the context structure for timeout-per-context, impact limitated to gfal and gfal 2.0 2012-04-17 17:39 molnarzs * RELEASE-NOTES, VERSION, packaging/rpm/specs/srm-ifce.spec: [ticket:]: Release notes updated for srm-ifce_R_1_1_1_1 2012-03-02 14:22 adevress * src/srmv2_data_transfer_functions.c: -correct asychronous put invalid token, GGUS ticket related to EOS 2012-02-14 12:59 adevress * packaging/rpm/specs/srm-ifce.spec: - increase spec file packaging release number [ticket:251] 2012-02-13 08:30 adevress * src/srmv2_space_management_functions.c: - correct again ^ 34 memory corruption from gsoap [ticket:274] 2012-02-12 21:42 adevress * CMakeLists.txt, src/CMakeLists.txt, src/srmv2_discovery_functions.c, src/srmv2_permission_functions.c: -correct memory corrpution from gsoapfor discovery and directories function [ticket:274] 2012-02-12 21:28 adevress * src/srmv2_directory_functions.c: -correct memory corrpution from gsoap [ticket:274] 2012-02-12 09:14 adevress * src/srmv2_data_transfer_functions.c: -add more fix for soap memory corruption in the srm-ifce [ticket:271] 2012-02-09 14:54 adevress * packaging/rpm/specs/srm-ifce.spec: -correct issue for fc18 [ticket:251] 2012-02-09 09:03 adevress * packaging/rpm/specs/srm-ifce.spec: - correct pakcaging problem after gsoap repackaging [ticket:251] 2012-02-02 13:01 adevress * packaging/rpm/specs/srm-ifce.spec: - remove macro on specfiles, bug on i686 [ticket:251] 2012-01-30 16:12 adevress * packaging/rpm/specs/srm-ifce.spec: - change versiong system 2012-01-30 16:08 adevress * packaging/rpm/specs/srm-ifce.spec, src/CMakeLists.txt, src/srm_util.c, src/srm_util.h, src/srmv2_data_transfer_functions.c, src/srmv2_directory_functions.c, src/srmv2_permission_functions.c: -fix the gsoap stack smash problem increase the version of srm-ifce for epel - change the versioning system 2012-01-16 14:39 adevress * packaging/bin/packager_rpm.sh, packaging/rpm/specs/srm-ifce.spec: -add source url tar - remvoe useless comments 2012-01-16 14:38 adevress * packaging/rpm/specs/srm-ifce.spec: -add the spec file modification for EPEL 2012-01-15 20:59 adevress * packaging/rpm/specs/srm-ifce.spec: -correct maro problem in rpmlint 2012-01-15 20:36 adevress * packaging/rpm/specs/srm-ifce.spec: -add new EPEL version 2012-01-13 12:33 adevress * cmake/modules/CMakeGeneratePkgConfig.cmake, cmake/modules/FindDCAP.cmake: -add cmake files 2012-01-13 10:55 adevress * cmake/modules/FindCGSI_GSOAP.cmake: -add emit version of cgsi gsoap for head compilation 2012-01-13 10:23 adevress * CMakeLists.txt, cmake/modules/CMakeGeneratePkgConfig.cmake, cmake/modules/FindCGSI_GSOAP.cmake, cmake/modules/FindgSOAP.cmake: -add missing cgsi FIND package 2012-01-13 09:43 adevress * cmake/modules/CMakeGeneratePkgConfig.cmake, cmake/modules/CMakeMacroParseArguments.cmake, cmake/modules/CMakeStringHelpers.cmake, cmake/modules/FindDPM.cmake, cmake/modules/FindLFC.cmake: -add missing cmake files 2012-01-13 09:12 adevress * CMakeLists.txt, cmake/modules/DefineInstallationPaths.cmake, packaging/rpm/specs/srm-ifce.spec, src/CMakeLists.txt: -add pkg-config auto-generation tools 2012-01-11 09:54 adevress * packaging/rpm/specs/srm-ifce.spec: -fix the include problem with gcc - create a branch for packaging 2012-01-11 09:12 adevress * src/srm_util.c: -patch srm_util include to avoid problem of deferenced pointer with gcc 4.6 ( rawhide, fedora 15/16 ) 2012-01-09 16:44 adevress * RELEASE-NOTES, VERSION, src/srm_util.c, test/execute_tests.sh, test/unit/execute_tests.sh: -merge the TLocality change 2012-01-05 10:10 adevress * packaging/rpm/specs/srm-ifce.spec: -remove the useless %doc macro ( docdir usage ) 2012-01-05 09:35 adevress * CMakeLists.txt, cmake/modules/DefineInstallationPaths.cmake, packaging/rpm/specs/srm-ifce.spec: -modify spec files and doc install dir for EPEL compliance 2011-12-16 16:02 adevress * packaging/rpm/specs/srm-ifce.spec: -replace place of documentation 2011-12-16 13:24 adevress * CMakeLists.txt, packaging/rpm/specs/srm-ifce.spec: - Improve spec file quality with the comments of my sponsor - change doc install dir - use cmake macro - remove isa macro for build req - correct recursive dependencies 2011-12-15 10:02 adevress * CMakeLists.txt, README, packaging/rpm/specs/srm-ifce.spec: -add README file for documentation purpose in the EPEL devel package 2011-12-15 10:00 adevress * src/gfal_srm_ifce.h, src/gfal_srm_ifce_internal.h, src/gfal_srm_ifce_systemtest.c, src/gfal_srm_ifce_types.h, src/gfal_srm_ifce_unittest.c, src/gfal_srm_ifce_unittest.h, src/gfal_srm_ifce_unittest_common.c, src/gfal_srm_ifce_unittest_srmls.c, src/srm_dependencies.c, src/srm_soap.h, src/srm_util.c, src/srm_util.h, src/srmv2_data_transfer_functions.c, src/srmv2_directory_functions.c: - remove execution right to source file, brings error to debuginfo generation 2011-12-15 09:55 adevress * CMakeLists.txt: -patch srm-ifce for debuginfo generation 2011-12-12 15:14 adevress * packaging/rpm/specs/srm-ifce.spec: -add srm ifce fix for the -libs dependencies -change bad summary 2011-12-02 12:21 adevress * cmake/modules/FindgSOAP.cmake: -correct gsoap macros 2011-12-02 12:19 adevress * packaging/rpm/specs/srm-ifce.spec: -hotfix the version number 2011-12-02 12:16 adevress * CMakeLists.txt: - correct specfiles in order to match the new files name 2011-12-02 10:53 adevress * CMakeLists.txt, cmake/modules/FindgSOAP.cmake, src/CMakeLists.txt: - add macro for gsoap backward compatibility 2011-12-01 16:51 adevress * CMakeLists.txt, cmake/modules/ReleaseDebugAutoFlags.cmake: -add release mode to the build 2011-12-01 15:25 adevress * packaging/rpm/specs/srm-ifce.spec: -correct spec file version number 2011-12-01 15:14 adevress * CMakeLists.txt, cmake, cmake/modules, cmake/modules/DefineInstallationPaths.cmake, cmake/modules/MacroCopyFile.cmake, m4-EPEL/ares.m4, m4-EPEL/boost.m4, m4-EPEL/ccheck.m4, m4-EPEL/cgsi-gsoap.m4, m4-EPEL/classads.m4, m4-EPEL/condorg.m4, m4-EPEL/cppunit.m4, m4-EPEL/db.m4, m4-EPEL/docbook_html.m4, m4-EPEL/docbook_man.m4, m4-EPEL/expat.m4, m4-EPEL/fcgi.m4, m4-EPEL/find_activemq.m4, m4-EPEL/find_apr.m4, m4-EPEL/glib2.m4, m4-EPEL/glite-version.m4, m4-EPEL/glite.m4, m4-EPEL/glite_ce.m4, m4-EPEL/glite_data.m4, m4-EPEL/glite_dgas.m4, m4-EPEL/glite_dgas_common.m4, m4-EPEL/glite_gpbox.m4, m4-EPEL/glite_gsoap_headernames.m4, m4-EPEL/glite_jdl.m4, m4-EPEL/glite_jobid.m4, m4-EPEL/glite_lb_nf.m4, m4-EPEL/glite_rgma.m4, m4-EPEL/glite_security.m4, m4-EPEL/glite_service_discovery.m4, m4-EPEL/glite_wms.m4, m4-EPEL/glite_wms_broker.m4, m4-EPEL/glite_wms_brokerinfo.m4, m4-EPEL/glite_wms_classad_plugin.m4, m4-EPEL/glite_wms_common.m4, m4-EPEL/glite_wms_helper.m4, m4-EPEL/glite_wms_ism.m4, m4-EPEL/glite_wms_jss.m4, m4-EPEL/glite_wms_matchmaking.m4, m4-EPEL/glite_wms_ns.m4, m4-EPEL/glite_wms_optional.m4, m4-EPEL/glite_wms_purger.m4, m4-EPEL/glite_wms_tp_bypass.m4, m4-EPEL/glite_wms_ui_optional.m4, m4-EPEL/glite_wms_wmproxy.m4, m4-EPEL/glite_wmsutils.m4, m4-EPEL/glite_wsdl_file.m4, m4-EPEL/globus-fix.m4, m4-EPEL/globus.m4, m4-EPEL/gridlist.m4, m4-EPEL/gridsite.m4, m4-EPEL/gsoap-fix.m4, m4-EPEL/gsoap.m4, m4-EPEL/gsoap_base.m4, m4-EPEL/httpd.m4, m4-EPEL/java.m4, m4-EPEL/jclassad.m4, m4-EPEL/jglobus.m4, m4-EPEL/lcmaps.m4, m4-EPEL/ldap.m4, m4-EPEL/libtar.m4, m4-EPEL/log4cpp.m4, m4-EPEL/log4cxx.m4, m4-EPEL/log4j.m4, m4-EPEL/ltdl-fix.m4, m4-EPEL/myproxy.m4, m4-EPEL/mysql-devel.m4, m4-EPEL/mysql.m4, m4-EPEL/optimize.m4, m4-EPEL/oracle-instantclient.m4, m4-EPEL/python-c.m4, m4-EPEL/python.m4, m4-EPEL/replica.m4, m4-EPEL/swig.m4, m4-EPEL/symbol-version.m4, m4-EPEL/unixodbc.m4, m4-EPEL/xalan.m4, m4-EPEL/xerces.m4, m4-EPEL/xml2.m4, m4-EPEL/zlib.m4, packaging/rpm/specs/srm-ifce.spec, src/CMakeLists.txt: -modify spec files for CMake - add the cmake macros - add headers to install - validate this 2011-12-01 13:57 adevress * CMakeLists.txt, src/CMakeLists.txt, src/srm_util.c: -add build support for CMake 2011-12-01 13:57 adevress * packaging/rpm/specs/srm-ifce.spec: add the no static lib flag -try to re-enable parallels builds - modify to put them in alphabetical order 2011-12-01 13:57 adevress * packaging/rpm/specs/srm-ifce.spec, src/Makefile.am: -revert changes to original ricardo spec file 2011-12-01 13:57 adevress * configure.ac, packaging/rpm/specs/srm-ifce.spec, src/Makefile.am: -add a way to disable static build - improve spec fiels with ricardo comments 2011-11-28 22:32 adevress * packaging/bin/packager_rpm.sh, packaging/rpm/specs/srm-ifce.spec: Merge branch 'rpm_trunk_local2' into tmp 2011-11-28 17:48 adevress * packaging/rpm/specs/srm-ifce.spec: -valdiate rebase 2011-11-28 15:34 rocha * packaging/rpm/specs/srm-ifce.spec: Proper macro usage, better description, no need for main rpm. 2011-11-28 10:31 adevress * packaging/rpm/specs/srm-ifce.spec: -improve spec files for epel 2011-11-24 17:22 adevress * packaging/rpm/specs/srm-ifce.spec, src/Makefile.am: -full EPEL compatible build 2011-11-24 12:53 adevress * packaging/rpm/specs/srm-ifce.spec: -modify specs files in order to disable tests generation 2011-11-24 12:53 adevress * configure.ac, src/Makefile.am: -add autotools macro in order to disable tests generation 2011-11-24 12:53 adevress * src/autogen/config.h, src/autogen/config.h.in, src/autogen/stamp-h1: remove generated files 2011-11-24 12:53 adevress * Makefile.in, src/Makefile.in: remove generated by configure files 2011-11-24 10:43 adevress * Makefile.in, m4-EPEL, m4-EPEL/ares.m4, m4-EPEL/boost.m4, m4-EPEL/ccheck.m4, m4-EPEL/cgsi-gsoap.m4, m4-EPEL/classads.m4, m4-EPEL/condorg.m4, m4-EPEL/cppunit.m4, m4-EPEL/db.m4, m4-EPEL/docbook_html.m4, m4-EPEL/docbook_man.m4, m4-EPEL/expat.m4, m4-EPEL/fcgi.m4, m4-EPEL/find_activemq.m4, m4-EPEL/find_apr.m4, m4-EPEL/glib2.m4, m4-EPEL/glite-version.m4, m4-EPEL/glite.m4, m4-EPEL/glite_ce.m4, m4-EPEL/glite_data.m4, m4-EPEL/glite_dgas.m4, m4-EPEL/glite_dgas_common.m4, m4-EPEL/glite_gpbox.m4, m4-EPEL/glite_gsoap_headernames.m4, m4-EPEL/glite_jdl.m4, m4-EPEL/glite_jobid.m4, m4-EPEL/glite_lb_nf.m4, m4-EPEL/glite_rgma.m4, m4-EPEL/glite_security.m4, m4-EPEL/glite_service_discovery.m4, m4-EPEL/glite_wms.m4, m4-EPEL/glite_wms_broker.m4, m4-EPEL/glite_wms_brokerinfo.m4, m4-EPEL/glite_wms_classad_plugin.m4, m4-EPEL/glite_wms_common.m4, m4-EPEL/glite_wms_helper.m4, m4-EPEL/glite_wms_ism.m4, m4-EPEL/glite_wms_jss.m4, m4-EPEL/glite_wms_matchmaking.m4, m4-EPEL/glite_wms_ns.m4, m4-EPEL/glite_wms_optional.m4, m4-EPEL/glite_wms_purger.m4, m4-EPEL/glite_wms_tp_bypass.m4, m4-EPEL/glite_wms_ui_optional.m4, m4-EPEL/glite_wms_wmproxy.m4, m4-EPEL/glite_wmsutils.m4, m4-EPEL/glite_wsdl_file.m4, m4-EPEL/globus-fix.m4, m4-EPEL/globus.m4, m4-EPEL/gridlist.m4, m4-EPEL/gridsite.m4, m4-EPEL/gsoap-fix.m4, m4-EPEL/gsoap.m4, m4-EPEL/gsoap_base.m4, m4-EPEL/httpd.m4, m4-EPEL/java.m4, m4-EPEL/jclassad.m4, m4-EPEL/jglobus.m4, m4-EPEL/lcmaps.m4, m4-EPEL/ldap.m4, m4-EPEL/libtar.m4, m4-EPEL/log4cpp.m4, m4-EPEL/log4cxx.m4, m4-EPEL/log4j.m4, m4-EPEL/ltdl-fix.m4, m4-EPEL/myproxy.m4, m4-EPEL/mysql-devel.m4, m4-EPEL/mysql.m4, m4-EPEL/optimize.m4, m4-EPEL/oracle-instantclient.m4, m4-EPEL/python-c.m4, m4-EPEL/python.m4, m4-EPEL/replica.m4, m4-EPEL/swig.m4, m4-EPEL/symbol-version.m4, m4-EPEL/unixodbc.m4, m4-EPEL/xalan.m4, m4-EPEL/xerces.m4, m4-EPEL/xml2.m4, m4-EPEL/zlib.m4, packaging, packaging/bin, packaging/bin/packager_rpm.sh, packaging/rpm, packaging/rpm/specs, packaging/rpm/specs/srm-ifce.spec, src/Makefile.in, src/autogen, src/autogen/config.h, src/autogen/config.h.in, src/autogen/stamp-h1: Merge branch 'rpms_epel' into rpm_epel_trunk_local 2011-11-24 10:19 adevress * .: Branch for EPEL packaging 2011-11-15 05:53 msalicho * one more attempt to fix 32bits 2011-11-14 19:45 msalicho * first attempt to fix 32bit build 2011-11-14 19:45 msalicho * first attempt to fix 32bit build 2011-09-14 16:06 molnarzs * Release candidate glite-data-srm-ifce_R_1_1_0_1 2011-09-12 18:04 molnarzs * Ticket [ticket:134] integrated. 2011-07-28 12:00 molnarzs * The memory leak hunt will be continued in a branch. Checking in everything before branching. 2011-07-20 16:23 adevress * -reverse change for the last chance expo backoff 2011-07-19 11:00 molnarzs * SrmLs tests extended to cover FTS use cases 2011-07-08 09:50 adevress * bug correction on set_permission() returned errcode 2011-06-14 12:05 adevress * -modification of the free functions for the recursive use case 2011-06-09 13:16 adevress * -modification of docs/comments 2011-06-09 13:14 adevress * -add proper file for the memory management - correct a license problem 2011-06-09 13:05 adevress * -modification of the exponential backoff for the timeout 2011-06-09 11:52 adevress * -add memory management function and associated doc 2011-06-08 14:40 adevress * - fix a bad SRM_ERROR -> errno error translation 2011-06-02 05:48 msalicho * remove DDEBUG to prevent gsoap logfiles creation 2011-03-26 06:50 msalicho * change ccheck macro name 2011-03-26 06:35 msalicho * change ccheck macro name 2011-02-23 13:57 msalicho * change gsoap version for EMI 2011-02-04 18:03 molnarzs * Integration candidate glite-data-srm-ifce_R_1_0_0 2011-02-04 11:24 molnarzs * - srm2_mkdir does not attempt to create the root directory - Bugfix in handling permission denied error when creating directories 2011-01-31 10:18 msalicho * EMI gsoap changes 2011-01-20 15:06 molnarzs * Savannah bug fix https://savannah.cern.ch/bugs/?52502 ported to srm-ifce 2011-01-20 12:16 molnarzs * Segmentation fault in unit tests for uninitialized pointer fixed 2011-01-20 10:33 molnarzs * Hard-coded resources from srm-ifce system tests removed. 2011-01-17 15:49 molnarzs * Segfault of srm_ls appeared in the nightly tests fixed. 2011-01-14 15:51 molnarzs * Negative values of count and offset values in srm-ls request cause EINVAL error on client side. 2010-12-03 16:32 tmanev * Fixing gfal-release test fail. 2010-12-03 16:28 tmanev * Fixing failing gfal-release test due to not proper bring online execution(it was not waiting for the end of bring_online queued). 2010-12-03 14:57 tmanev * Reverted back to old behaviour to have positive result even if only one(not all) filestatus returned. 2010-12-02 16:13 tmanev * Fixed gfal-prestagestatus test fail. 2010-12-02 15:42 tmanev * Fixing some of the failing python gfal tests. 2010-12-02 13:08 tmanev * Fixing gfal-get and gfal-getstatus tests. 2010-12-01 14:40 tmanev * Fixing some of the failing gfal api python tests. 2010-11-30 16:04 tmanev * Fixing systemtests. 2010-11-30 15:04 tmanev * Fixing tests for ls,put,bring online according to bug 52893. 2010-11-30 13:30 tmanev * Fixing tests gfal-pin and gfal-unlink. 2010-11-30 12:44 tmanev * Fixing gfal-open test and unittests. 2010-11-30 10:34 tmanev * Added test for unexistent file permission check. Fixed failing gfal_access test. 2010-11-29 15:41 tmanev * Added srmPurgeFromSpace to space management functions. According to savannah bug #49578. 2010-11-26 16:25 tmanev * Improved error message handling. First string [SE] is now stored in one const variable - err_msg_begin. 2010-11-26 13:19 tmanev * Change srm_context_init function added input parameters for errbuf errbufsz and verbose. 2010-11-26 11:13 tmanev * Fixing savannah bug #75530. Added setup of errno on multiple places. 2010-11-25 16:28 tmanev * Script cleanup. 2010-11-25 15:58 tmanev * Removed lib from the script. 2010-11-25 15:50 tmanev * Added first parameter to be added in LD path. 2010-11-25 15:30 tmanev * Show libdir variable. 2010-11-25 13:32 tmanev * Removed change of LD_LIBRARY_PATH. 2010-11-25 11:06 tmanev * Added setup of LD folder before execution of the tests. 2010-11-24 13:27 tmanev * Clean up of commented srm_types. 2010-11-24 13:18 tmanev * Test execution script, fixed to work no matter from where it is executed. 2010-11-24 13:06 tmanev * Add unittest script folder. 2010-11-24 13:04 tmanev * Added EGEE copyright headers. 2010-11-24 10:29 tmanev * Revert back to verbose test results. 2010-11-24 10:28 tmanev * Fixed seg fault in unittests, code cleaned up, added NOFORK capabilities for easier debug. 2010-11-23 14:25 tmanev * Removed unused files from srm-ifce library. 2010-11-23 14:22 tmanev * Removed unused file generation. 2010-11-23 10:19 tmanev * Reverted to the previous gfal enum definitions.(in order not to change dm-util). 2010-11-22 14:33 tmanev * Added globus to configuration. 2010-11-19 16:21 tmanev * Added test folder. 2010-11-19 15:40 tmanev * Added globus dependency due to cgsi dependency. 2010-11-19 14:09 tmanev * Missing CCHECK_CFLAGS. 2010-11-19 12:59 tmanev * Clear warning white space following backslash in makefile.am 2010-11-19 12:38 tmanev * Added m4 macro to build-common-cpp. Adjust configuration and makefile. 2010-11-19 10:52 tmanev * Added ccheck to configuration and include. 2010-11-19 10:21 tmanev * Added gfal_srm_ifce_systemtest binary to the build. 2010-11-19 09:54 tmanev * Fixed build of binaries. 2010-11-19 09:45 tmanev * Fixed linking. Making baniries left. 2010-11-19 09:28 tmanev * Fix compilation. Linking left. 2010-11-19 08:53 molnarzs * Autotools introduced 2010-11-17 13:32 tmanev * Added last chance attempt to the backoff logic, will attempt 2 sec before the timeout. 2010-11-17 10:22 tmanev * Added estimated wait time for request and for file in data transfer functions. 2010-11-17 09:20 tmanev * Async calls wrong function calls. 2010-11-17 09:16 tmanev * Fix one typo. 2010-11-16 15:26 tmanev * Remove various printf in srm_test added verbose output of the test, for better parsing and integration of test results. 2010-11-12 13:42 tmanev * Imporved srm permissions test. 2010-11-12 09:05 tmanev * Fix rmdir unittest. 2010-11-11 12:44 tmanev * Added set/check/get permssions check in srm_test . 2010-11-10 16:47 tmanev * Removed some lcg utils calls fixed mkdir test. Now srm_test only depends on lcg-cp. 2010-11-10 13:43 tmanev * rm_dir returns 1 upon successful directory removal in order to be compatible with the old srm code. 2010-11-08 16:29 tmanev * Empty srm_compy function removed. 2010-11-08 15:52 tmanev * Fixing various bugs in srm_test. 2010-11-08 13:56 tmanev * Fix uninitialized output variables,by memset 0 for srm output structures. 2010-11-05 12:26 tmanev * Fixed Segmentation fault, on double call of bring online. Because of uninitialized request variables of srm abort request. 2010-11-03 11:53 tmanev * Add regression unittest for the mkdir last level directory creation problem. 2010-11-03 09:54 tmanev * Fixing bug of mkdir - last level folder was not created. (fix provided by Ronny Tschueter) 2010-07-28 08:45 tmanev * Fixed wrong commit, from is-interface files. 2010-07-28 08:40 tmanev * cornel configuration script for is-interface wrongly submitted. 2010-07-28 08:40 tmanev * cornel configuration script for is-interface wrongly submitted. 2010-07-27 09:55 cmicu * glib dependencies configuration. 2010-07-27 09:55 cmicu * changed permissions. 2010-07-20 12:25 tmanev * Set output token for synchroneous calls to NULL, in the begining of the calls. 2010-07-13 15:58 tmanev * Added version wrapper for check permission. 2010-07-13 11:58 tmanev * srm extend file lifetime fixed input/output parameters, according to the template. 2010-07-13 07:38 tmanev * Clear a warning, for incompatible pointer types. 2010-07-12 09:45 tmanev * Making the make file build with 32 bit. 2010-07-09 07:59 tmanev * 2010-07-08 15:09 tmanev * prepare was written prepeare in some of the functions. 2010-07-08 14:53 tmanev * Added version wrapper for prepare to put and prepare to get and status of put/get request synchronious calls. 2010-07-07 14:07 tmanev * Fixed verious segmentation faults in unittests due to uninitialized variables in the test and some. 2010-07-06 09:19 tmanev * Removed voms from makefile and configuration file. Changed to stage folder. 2010-07-05 11:25 tmanev * 2010-07-05 11:20 tmanev * missing coma in config file. 2010-07-05 10:03 tmanev * cchek location added. 2010-07-05 09:28 tmanev * Added ccheck folders in configuration script and makefile. 2010-07-02 15:13 tmanev * 2010-07-02 15:03 tmanev * Delete automake file. 2010-07-02 15:02 tmanev * Delete automake scripts. 2010-07-02 15:02 tmanev * Delete auto make files. 2010-07-02 14:27 tmanev * 2010-07-02 13:18 tmanev * 2010-07-02 12:27 tmanev * 2010-07-02 12:23 tmanev * Makefile changes, remove automake. 2010-07-02 07:50 tmanev * Wrong function prototype. 2010-06-29 15:13 tmanev * 2010-06-29 13:41 tmanev * 2010-06-25 15:09 tmanev * 2010-06-25 13:35 tmanev * 2010-06-24 15:05 tmanev * 2010-06-24 13:18 tmanev * Removed various warnings. 2010-06-24 11:36 tmanev * Clearing various warnings and errors. 2010-06-24 08:11 tmanev * Added srm_context_init function. Removed some dependencies. 2010-06-22 13:46 tmanev * 2010-06-17 13:38 tmanev * 2010-06-17 12:19 tmanev * 2010-06-10 14:29 tmanev * 2010-06-09 15:08 tmanev * 2010-06-07 15:55 tmanev * 2010-06-07 13:06 tmanev * 2010-06-04 15:33 tmanev * 2010-06-03 14:57 tmanev * 2010-06-02 15:32 tmanev * 2010-06-02 13:48 tmanev * 2010-06-01 15:45 tmanev * 2010-06-01 15:33 tmanev * 2010-06-01 15:17 tmanev * 2010-06-01 14:54 tmanev * 2010-06-01 13:14 tmanev * 2010-06-01 12:32 tmanev * 2010-06-01 12:11 tmanev * 2010-05-31 16:14 tmanev * 2010-05-31 13:46 tmanev * 2010-05-28 15:58 tmanev * 2010-05-28 08:51 tmanev * 2010-05-27 13:15 tmanev * 2010-05-27 10:02 tmanev * 2010-05-27 08:16 tmanev * 2010-05-26 16:06 tmanev * 2010-05-26 14:14 tmanev * 2010-05-26 11:57 tmanev * 2010-05-25 15:58 tmanev * 2010-05-25 13:23 tmanev * 2010-05-25 12:49 tmanev * 2010-05-25 12:48 tmanev * 2010-05-25 12:47 tmanev * 2010-05-25 11:39 tmanev * 2010-05-25 09:13 tmanev * 2010-05-21 17:10 tmanev * 2010-05-21 14:08 tmanev * 2010-05-20 15:42 tmanev * 2010-05-20 09:41 tmanev * 2010-05-19 14:02 tmanev * 2010-05-18 15:40 tmanev * 2010-05-18 12:31 tmanev * 2010-05-17 16:16 tmanev * 2010-05-07 12:03 tmanev * 2010-05-07 06:58 tmanev * 2010-05-06 14:21 tmanev * 2010-05-04 09:44 tmanev * 2010-05-04 08:55 tmanev * 2010-05-04 07:26 tmanev * 2010-05-03 13:53 tmanev * 2010-04-23 09:22 molnarzs * First import srm-ifce-1.18.0/test/0000755001662700052000000000000012217066060013257 5ustar adevresscgsrm-ifce-1.18.0/test/unit/0000755001662700052000000000000012217066060014236 5ustar adevresscgsrm-ifce-1.18.0/test/unit/execute_tests.sh0000755001662700052000000000226212217066060017463 0ustar adevresscg#! /bin/bash # Copyright (c) Members of the EGEE Collaboration. 2004. # See http://www.eu-egee.org/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. # Execute the unit tests # Author:Todor Manev CERN IT-GT SCRIPT=$(readlink -f $0) SCRIPTPATH=`dirname $SCRIPT` BUILD_DIR=$SCRIPTPATH/../../build #script is in /test/unit ccheck_path=`locate libcheck.so.0 | head -1 | sed 's/libcheck.so.0//'` cgsi_path=`locate libcgsi_plugin_gsoap_2.7.so.1 | head -1 | sed 's/libcgsi_plugin_gsoap_2.7.so.1//'` export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ccheck_path:$cgsi_path pushd $BUILD_DIR/src &> /dev/null ./gfal_srm_ifce_unittest res=$? popd &> /dev/null exit $res srm-ifce-1.18.0/test/execute_tests.sh0000755001662700052000000000326312217066060016506 0ustar adevresscg#! /bin/bash # Copyright (c) Members of the EGEE Collaboration. 2010. # See http://www.eu-egee.org/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. # Execute test suites (unit and regression tests). # Authors: Todor Manev IT-GT CERN SCRIPT=$(readlink -f $0) SCRIPTPATH=`dirname $SCRIPT` #if [ $(uname -m) == "x86_64" ]; then # LIB_FOLDER_TYPE=lib64 #else # LIB_FOLDER_TYPE=lib #fi #if [ -n "$1" ]; then # export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$1 #fi sudo updatedb ccheck_path=`locate libcheck.so.0 | head -1 | sed 's/libcheck.so.0//'` cgsi_path=`locate libcgsi_plugin_gsoap_2.7.so.1 | head -1 | sed 's/libcgsi_plugin_gsoap_2.7.so.1//'` export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ccheck_path:$cgsi_path function execute_test { local testdir=$SCRIPTPATH/$1 echo -e "\nExecuting test suite \"$1\"\n" pushd $testdir &> /dev/null ./execute_tests.sh local res=$? popd &> /dev/null if [ $res != 0 ] ; then echo echo -e "\nA test in \"$testdir\" failed.\n" exit 1 fi echo -e "\nAll tests in \"$testdir\" passed.\n" } execute_test unit #execute_test regression #execute_test certification_tests srm-ifce-1.18.0/DESCRIPTION0000644001662700052000000000024012217066060014002 0ustar adevresscgThe Grid File Access Library offers a POSIX interface to Replica Catalogs, Storage Resource Managers and File Access services using protocols like rfio, dcap...srm-ifce-1.18.0/README0000644001662700052000000000037212217066060013162 0ustar adevresscgsrm-ifce is a client side implementation of the SRMv1 and SRMv2 specification for GFAL and FTS. SRM means Storage Resource Manager Interface, it is a specification of a SOAP interface providing a generic way to manage distributed storage systems. srm-ifce-1.18.0/cmake/0000755001662700052000000000000012217066060013360 5ustar adevresscgsrm-ifce-1.18.0/cmake/modules/0000755001662700052000000000000012217066060015030 5ustar adevresscgsrm-ifce-1.18.0/cmake/modules/CMakeMacroParseArguments.cmake0000644001662700052000000000206512217066060022660 0ustar adevresscg MACRO(PARSE_ARGUMENTS prefix arg_names option_names) SET(DEFAULT_ARGS) FOREACH(arg_name ${arg_names}) SET(${prefix}_${arg_name}) ENDFOREACH(arg_name) FOREACH(option ${option_names}) SET(${prefix}_${option} FALSE) ENDFOREACH(option) SET(current_arg_name DEFAULT_ARGS) SET(current_arg_list) FOREACH(arg ${ARGN}) SET(larg_names ${arg_names}) LIST(FIND larg_names "${arg}" is_arg_name) IF (is_arg_name GREATER -1) SET(${prefix}_${current_arg_name} ${current_arg_list}) SET(current_arg_name ${arg}) SET(current_arg_list) ELSE (is_arg_name GREATER -1) SET(loption_names ${option_names}) LIST(FIND loption_names "${arg}" is_option) IF (is_option GREATER -1) SET(${prefix}_${arg} TRUE) ELSE (is_option GREATER -1) SET(current_arg_list ${current_arg_list} ${arg}) ENDIF (is_option GREATER -1) ENDIF (is_arg_name GREATER -1) ENDFOREACH(arg) SET(${prefix}_${current_arg_name} ${current_arg_list}) ENDMACRO(PARSE_ARGUMENTS) srm-ifce-1.18.0/cmake/modules/MacroCopyFile.cmake0000644001662700052000000000215712217066060020533 0ustar adevresscg# - macro_copy_file(_src _dst) # Copies a file to ${_dst} only if ${_src} is different (newer) than ${_dst} # # Example: # macro_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/icon.png ${CMAKE_CURRENT_BINARY_DIR}/.) # Copies file icon.png to ${CMAKE_CURRENT_BINARY_DIR} directory # # Copyright (c) 2006-2007 Wengo # Copyright (c) 2006-2008 Andreas Schneider # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING file. macro (macro_copy_file _src _dst) # Removes all path containing .svn or CVS or CMakeLists.txt during the copy if (NOT ${_src} MATCHES ".*\\.svn|CVS|CMakeLists\\.txt.*") if (CMAKE_VERBOSE_MAKEFILE) message(STATUS "Copy file from ${_src} to ${_dst}") endif (CMAKE_VERBOSE_MAKEFILE) # Creates directory if necessary get_filename_component(_path ${_dst} PATH) file(MAKE_DIRECTORY ${_path}) execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different ${_src} ${_dst} OUTPUT_QUIET ) endif (NOT ${_src} MATCHES ".*\\.svn|CVS|CMakeLists\\.txt.*") endmacro (macro_copy_file) srm-ifce-1.18.0/cmake/modules/FindgSOAP.cmake0000644001662700052000000000722112217066060017546 0ustar adevresscg# # This module detects if gsoap is installed and determines where the # include files and libraries are. # # This code sets the following variables: # # GSOAP_LIBRARIES = full path to the gsoap libraries # GSOAP_SSL_LIBRARIES = full path to the gsoap ssl libraries # GSOAP_INCLUDE_DIR = include dir to be used when using the gsoap library # GSOAP_WSDL2H = wsdl2h binary # GSOAP_SOAPCPP2 = soapcpp2 binary # GSOAP_FOUND = set to true if gsoap was found successfully # # GSOAP_LOCATION # setting this enables search for gsoap libraries / headers in this location # ------------------------------------------------------ # try pkg config search # # ----------------------------------------------------- find_package(PkgConfig) pkg_check_modules(PC_GSOAP QUIET gsoap) IF(PC_GSOAP_FOUND) SET(GSOAP_LIBRARIES ${PC_GSOAP_LIBRARIES}) SET(GSOAP_INCLUDE_DIR ${PC_GSOAP_INCLUDE_DIRS}) SET(GSOAP_DEFINITIONS "${PC_GSOAP_CFLAGS} ${PC_GSOAP_CFLAGS_OTHER}") ELSE(PC_GSOAP_FOUND) # ----------------------------------------------------- # GSOAP Libraries # ----------------------------------------------------- find_library(GSOAP_LIBRARIES NAMES gsoap HINTS ${GSOAP_LOCATION}/lib ${GSOAP_LOCATION}/lib64 ${GSOAP_LOCATION}/lib32 DOC "The main gsoap library" ) # ----------------------------------------------------- # GSOAP Include Directories # ----------------------------------------------------- find_path(GSOAP_INCLUDE_DIR NAMES stdsoap2.h HINTS ${GSOAP_LOCATION} ${GSOAP_LOCATION}/include ${GSOAP_LOCATION}/include/* DOC "The gsoap include directory" ) SET(GSOAP_DEFINITIONS "") ENDIF(PC_GSOAP_FOUND) # ----------------------------------------------------- # GSOAP ssl Libraries # ----------------------------------------------------- find_library(GSOAP_SSL_LIBRARIES NAMES gsoapssl HINTS ${GSOAP_LOCATION}/lib ${GSOAP_LOCATION}/lib64 ${GSOAP_LOCATION}/lib32 DOC "The ssl gsoap library" ) # ----------------------------------------------------- # GSOAP Binaries # ----------------------------------------------------- find_program(GSOAP_WSDL2H NAMES wsdl2h HINTS ${GSOAP_LOCATION}/bin DOC "The gsoap bin directory" ) find_program(GSOAP_SOAPCPP2 NAMES soapcpp2 HINTS ${GSOAP_LOCATION}/bin DOC "The gsoap bin directory" ) # ----------------------------------------------------- # GSOAP_276_COMPAT_FLAGS and GSOAPVERSION # try to determine the flagfor the 2.7.6 compatiblity, break with 2.7.13 and re-break with 2.7.16 # ---------------------------------------------------- message(STATUS " - wsdlh : ${GSOAP_WSDL2H}") message(STATUS " - SOAPCPP2 : ${GSOAP_SOAPCPP2}") execute_process(COMMAND ${GSOAP_SOAPCPP2} "-v" OUTPUT_VARIABLE GSOAP_STRING_VERSION ERROR_VARIABLE GSOAP_STRING_VERSION ) string(REGEX MATCH "[0-9]*\\.[0-9]*\\.[0-9]*" GSOAP_VERSION ${GSOAP_STRING_VERSION}) message(STATUS " - GSOAP VERSION : ${GSOAP_VERSION}") if( "${GSOAP_VERSION}" VERSION_LESS "2.7.6") set(GSOAP_276_COMPAT_FLAGS "") elseif ( "${GSOAP_VERSION}" VERSION_LESS "2.7.14") set(GSOAP_276_COMPAT_FLAGS "-z") else ( "${GSOAP_VERSION}" VERSION_LESS "2.7.14") set(GSOAP_276_COMPAT_FLAGS "-z1 -z2") endif ( "${GSOAP_VERSION}" VERSION_LESS "2.7.6") # ----------------------------------------------------- # handle the QUIETLY and REQUIRED arguments and set GSOAP_FOUND to TRUE if # all listed variables are TRUE # ----------------------------------------------------- include(FindPackageHandleStandardArgs) find_package_handle_standard_args(gsoap DEFAULT_MSG GSOAP_LIBRARIES GSOAP_INCLUDE_DIR GSOAP_WSDL2H GSOAP_SOAPCPP2) mark_as_advanced(GSOAP_INCLUDE_DIR GSOAP_LIBRARIES GSOAP_WSDL2H GSOAP_SOAPCPP2) srm-ifce-1.18.0/cmake/modules/FindDCAP.cmake0000644001662700052000000000305212217066060017342 0ustar adevresscg# # This module detects if DCAP is installed and determines where the # include files and libraries are. # # This code sets the following variables: # # DCAP_LIBRARIES = full path to the DCAP libraries # DCAP_INCLUDE_DIR = include dir to be used when using the DCAP library # DCAP_FOUND = set to true if DCAP was found successfully # # DCAP_LOCATION # setting this enables search for DCAP libraries / headers in this location # ----------------------------------------------------- # DCAP Libraries # ----------------------------------------------------- find_library(DCAP_LIBRARIES NAMES dcap HINTS ${DCAP_LOCATION}/lib ${DCAP_LOCATION}/lib64 ${DCAP_LOCATION}/lib32 ${STAGE_DIR}/lib ${STAGE_DIR}/lib64 DOC "The main DCAP library" ) # ----------------------------------------------------- # DCAP Include Directories # ----------------------------------------------------- find_path(DCAP_INCLUDE_DIR NAMES dcap.h HINTS ${DCAP_LOCATION} ${DCAP_LOCATION}/include ${DCAP_LOCATION}/include/* ${STAGE_DIR}/include DOC "The DCAP include directory" ) if(DCAP_INCLUDE_DIR) message(STATUS "DCAP includes found in ${DCAP_INCLUDE_DIR}") endif() # ----------------------------------------------------- # handle the QUIETLY and REQUIRED arguments and set DCAP_FOUND to TRUE if # all listed variables are TRUE # ----------------------------------------------------- include(FindPackageHandleStandardArgs) find_package_handle_standard_args(DCAP DEFAULT_MSG DCAP_LIBRARIES DCAP_INCLUDE_DIR) mark_as_advanced(DCAP_INCLUDE_DIR DCAP_LIBRARIES) srm-ifce-1.18.0/cmake/modules/FindDPM.cmake0000644001662700052000000000445212217066060017260 0ustar adevresscg# # This module detects if dpm is installed and determines where the # include files and libraries are. # # This code sets the following variables: # # DPM_LIBRARIES = full path to the dpm libraries # DPM_INCLUDE_DIR = include dir to be used when using the dpm library # DPM_FOUND = set to true if dpm was found successfully # # DPM_LOCATION # setting this enables search for dpm libraries / headers in this location # ----------------------------------------------------- # DPM Libraries # ----------------------------------------------------- find_library(DPM_LIBRARIES NAMES dpm HINTS ${DPM_LOCATION}/lib ${DPM_LOCATION}/lib64 ${DPM_LOCATION}/lib32 DOC "The main dpm library" ) # ----------------------------------------------------- # LCGDM Libraries # ----------------------------------------------------- find_library(LCGDM_LIBRARIES NAMES lcgdm HINTS ${DPM_LOCATION}/lib ${DPM_LOCATION}/lib64 ${DPM_LOCATION}/lib32 DOC "The main lcgdm library" ) # ----------------------------------------------------- # DPM Include Directories # ----------------------------------------------------- find_path(DPM_INCLUDE_DIR NAMES dpm/dpm_api.h HINTS ${DPM_LOCATION} ${DPM_LOCATION}/include ${DPM_LOCATION}/include/* DOC "The dpm include directory" ) if(DPM_INCLUDE_DIR) message(STATUS "dpm includes found in ${DPM_INCLUDE_DIR}") endif() # ----------------------------------------------------- # LCGDM Include Directories # ----------------------------------------------------- find_path(LCGDM_INCLUDE_DIR NAMES Cinit.h HINTS ${LCGDM_LOCATION} ${LCGDM_LOCATION}/include ${LCGDM_LOCATION}/include/lcgdm /usr/include/lcgdm DOC "The LCGDM include directory" ) if(LCGDM_INCLUDE_DIR) message(STATUS "lcgdm includes found in ${LCGDM_INCLUDE_DIR}") endif() # ----------------------------------------------------- # handle the QUIETLY and REQUIRED arguments and set DPM_FOUND to TRUE if # all listed variables are TRUE # ----------------------------------------------------- include(FindPackageHandleStandardArgs) find_package_handle_standard_args(dpm DEFAULT_MSG DPM_LIBRARIES DPM_INCLUDE_DIR) find_package_handle_standard_args(lcgdm DEFAULT_MSG LCGDM_LIBRARIES LCGDM_INCLUDE_DIR) mark_as_advanced(DPM_INCLUDE_DIR DPM_LIBRARIES) mark_as_advanced(LCGDM_INCLUDE_DIR LCGDM_LIBRARIES) srm-ifce-1.18.0/cmake/modules/ReleaseDebugAutoFlags.cmake0000644001662700052000000000027112217066060022167 0ustar adevresscg## debug / release autoManagement set(CMAKE_C_FLAGS_RELEASE "-O3") set(CMAKE_C_FLAGS_DEBUG "-g -Wall") set(CMAKE_CXX_FLAGS_RELEASE "-O3") set(CMAKE_CXX_FLAGS_DEBUG "-g -Wall") srm-ifce-1.18.0/cmake/modules/FindLFC.cmake0000644001662700052000000000273112217066060017242 0ustar adevresscg# # This module detects if LFC is installed and determines where the # include files and libraries are. # # This code sets the following variables: # # LFC_LIBRARIES = full path to the LFC libraries # LFC_INCLUDE_DIR = include dir to be used when using the LFC library # LFC_FOUND = set to true if LFC was found successfully # # LFC_LOCATION # setting this enables search for LFC libraries / headers in this location # ----------------------------------------------------- # LFC Libraries # ----------------------------------------------------- find_library(LFC_LIBRARIES NAMES lfc lcgdm HINTS ${LFC_LOCATION}/lib ${LFC_LOCATION}/lib64 ${LFC_LOCATION}/lib32 DOC "The main LFC library" ) # ----------------------------------------------------- # LFC Include Directories # ----------------------------------------------------- find_path(LFC_INCLUDE_DIR NAMES lfc/lfc_api.h HINTS ${LFC_LOCATION} ${LFC_LOCATION}/include ${LFC_LOCATION}/include/* DOC "The LFC include directory" ) if(LFC_INCLUDE_DIR) message(STATUS "LFC includes found in ${LFC_INCLUDE_DIR}") endif() # ----------------------------------------------------- # handle the QUIETLY and REQUIRED arguments and set LFC_FOUND to TRUE if # all listed variables are TRUE # ----------------------------------------------------- include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LFC DEFAULT_MSG LFC_LIBRARIES LFC_INCLUDE_DIR) mark_as_advanced(LFC_INCLUDE_DIR LFC_LIBRARIES) srm-ifce-1.18.0/cmake/modules/FindCGSI_GSOAP.cmake0000644001662700052000000000377612217066060020326 0ustar adevresscg# # This module detects if CGSI_GSOAP is installed and determines where the # include files and libraries are. # # This code sets the following variables: # # CGSI_GSOAP_LIBRARIES = full path to the CGSI_GSOAP libraries # CGSI_GSOAP_INCLUDE_DIRS = include dir to be used when using the CGSI_GSOAP library # CGSI_GSOAP_FOUND = set to true if CGSI_GSOAP was found successfully # # CGSI_GSOAP_LOCATION # setting this enables search for CGSI_GSOAP libraries / headers in this location include(CMakeStringHelpers) # ----------------------------------------------------- # CGSI_GSOAP Libraries # ----------------------------------------------------- find_library(CGSI_GSOAP_PATH NAMES cgsi_plugin cgsi_plugin_gsoap_2.7 HINTS ${CGSI_GSOAP_LOCATION}/lib ${CGSI_GSOAP_LOCATION}/lib64 ${CGSI_GSOAP_LOCATION}/lib32 ${STAGE_DIR}/lib ${STAGE_DIR}/lib64 DOC "The main CGSI_GSOAP library" ) if(CGSI_GSOAP_PATH) parse_lib_path("CGSI_GSOAP_LIBRARIES" "CGSI_GSOAP_LIBRARY_DIRS" ${CGSI_GSOAP_PATH}) #message( " link ${CGSI_GSOAP_LIBRARIES} path ${CGSI_GSOAP_LIBRARY_DIRS}") endif(CGSI_GSOAP_PATH) # ----------------------------------------------------- # CGSI_GSOAP Include Directories # ----------------------------------------------------- find_path(CGSI_GSOAP_INCLUDE_DIRS NAMES cgsi_plugin.h HINTS ${CGSI_GSOAP_LOCATION} ${CGSI_GSOAP_LOCATION}/include ${CGSI_GSOAP_LOCATION}/include/* ${STAGE_DIR}/include ${STAGE_DIR}/include DOC "The CGSI_GSOAP include directory" ) if(CGSI_GSOAP_INCLUDE_DIRS) message(STATUS "CGSI_GSOAP includes found in ${CGSI_GSOAP_INCLUDE_DIRS}") endif() # ----------------------------------------------------- # handle the QUIETLY and REQUIRED arguments and set CGSI_GSOAP_FOUND to TRUE if # all listed variables are TRUE # ----------------------------------------------------- include(FindPackageHandleStandardArgs) find_package_handle_standard_args(CGSI_GSOAP DEFAULT_MSG CGSI_GSOAP_PATH) mark_as_advanced(CGSI_GSOAP_INCLUDE_DIRS CGSI_GSOAP_LIBRARIES CGSI_GSOAP_LIBRARY_DIRS) srm-ifce-1.18.0/cmake/modules/DefineInstallationPaths.cmake0000644001662700052000000001017112217066060022606 0ustar adevresscgif (UNIX) IF (NOT APPLICATION_NAME) MESSAGE(STATUS "${PROJECT_NAME} is used as APPLICATION_NAME") SET(APPLICATION_NAME ${PROJECT_NAME}) ENDIF (NOT APPLICATION_NAME) # Suffix for Linux IF (CMAKE_SIZEOF_VOID_P EQUAL 4) SET(LIB_SUFFIX "" CACHE STRING "Suffix of the lib") SET (PKG_ARCH "i386") ELSE (CMAKE_SIZEOF_VOID_P EQUAL 4) SET(LIB_SUFFIX "64" CACHE STRING "Suffix of the lib") SET (PKG_ARCH "x86_64") ENDIF (CMAKE_SIZEOF_VOID_P EQUAL 4) SET(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "Base directory for executables and libraries" ) SET(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" CACHE PATH "Base directory for files which go to share/" ) SET(DATA_INSTALL_PREFIX "${SHARE_INSTALL_PREFIX}/${APPLICATION_NAME}" CACHE PATH "The parent directory where applications can install their data") # The following are directories where stuff will be installed to SET(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" CACHE PATH "The ${APPLICATION_NAME} binary install dir (default prefix/bin)" ) SET(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" CACHE PATH "The ${APPLICATION_NAME} sbin install dir (default prefix/sbin)" ) SET(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is prefix/lib)" ) SET(LIBEXEC_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/libexec" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is prefix/libexec)" ) SET(PKGCONFIG_FILES_DIR "${LIB_INSTALL_DIR}/pkgconfig/" CACHE PATH "subdirectory relative to the install prefix where pkgconfig files (.pc) will be installed" ) SET(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/${APPLICATION_NAME}" CACHE PATH "The subdirectory relative to the install prefix where plugins will be installed (default is prefix/lib/${APPLICATION_NAME})" ) SET(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The subdirectory to the header prefix (default prefix/include)" ) SET(DATA_INSTALL_DIR "${DATA_INSTALL_PREFIX}" CACHE PATH "The parent directory where applications can install their data (default prefix/share/${APPLICATION_NAME})" ) SET(DOC_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/${APPLICATION_NAME}" CACHE PATH "The parent directory where applications can install their documentation (default prefix/share/doc/${APPLICATION_NAME})" ) SET(HTML_INSTALL_DIR "${DATA_INSTALL_PREFIX}/doc/HTML" CACHE PATH "The HTML install dir for documentation (default data/doc/html)" ) SET(ICON_INSTALL_DIR "${DATA_INSTALL_PREFIX}/icons" CACHE PATH "The icon install dir (default data/icons/)" ) SET(SOUND_INSTALL_DIR "${DATA_INSTALL_PREFIX}/sounds" CACHE PATH "The install dir for sound files (default data/sounds)" ) SET(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" CACHE PATH "The install dir for translations (default prefix/share/locale)" ) SET(XDG_APPS_DIR "${SHARE_INSTALL_PREFIX}/applications/" CACHE PATH "The XDG apps dir" ) SET(XDG_DIRECTORY_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" CACHE PATH "The XDG directory" ) SET(SYSCONF_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/etc" CACHE PATH "The ${APPLICATION_NAME} sysconfig install dir (default prefix/etc)" ) SET(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" CACHE PATH "The ${APPLICATION_NAME} man install dir (default prefix/man)" ) SET(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" CACHE PATH "The ${APPLICATION_NAME} info install dir (default prefix/info)" ) endif (UNIX) if (WIN32) # Same same set(BIN_INSTALL_DIR "." CACHE PATH "-") set(SBIN_INSTALL_DIR "." CACHE PATH "-") set(LIB_INSTALL_DIR "lib" CACHE PATH "-") set(INCLUDE_INSTALL_DIR "include" CACHE PATH "-") set(PLUGIN_INSTALL_DIR "plugins" CACHE PATH "-") set(HTML_INSTALL_DIR "doc/HTML" CACHE PATH "-") set(ICON_INSTALL_DIR "." CACHE PATH "-") set(SOUND_INSTALL_DIR "." CACHE PATH "-") set(LOCALE_INSTALL_DIR "lang" CACHE PATH "-") endif (WIN32) srm-ifce-1.18.0/cmake/modules/CMakeStringHelpers.cmake0000644001662700052000000000324412217066060021527 0ustar adevresscg##convenience function for string manipulation function(replace_occurence output input pattern replacer) string(REGEX REPLACE ${pattern} ${replacer} tmp_str ${input}) set(${output} ${tmp_str} PARENT_SCOPE) endfunction(replace_occurence output input pattern replacer) function(replace_all_occurence) PARSE_ARGUMENTS(REPLACE_ALL "LIST_PATTERN;LIST_REPLACER" "" ${ARGN} ) LIST(APPEND list_pattern ${REPLACE_ALL_LIST_PATTERN}) LIST(APPEND list_replacer ${REPLACE_ALL_LIST_REPLACER}) LIST(LENGTH list_pattern list_size ) LIST(LENGTH list_replacer list2_size ) math(EXPR list_size ${list_size}-1) LIST(GET REPLACE_ALL_DEFAULT_ARGS 0 output_var) LIST(GET REPLACE_ALL_DEFAULT_ARGS 1 intput_content ) SET(tmp_str ${intput_content}) SET(tmp_str2 "") foreach(i RANGE ${list_size}) list(GET list_pattern ${i} current_pattern ) list(GET list_replacer ${i} current_replacer ) replace_occurence(tmp_str2 ${tmp_str} ${current_pattern} ${current_replacer} ) SET(tmp_str ${tmp_str2}) endforeach(i RANGE ${list_size}) SET(${output_var} ${tmp_str} PARENT_SCOPE) endfunction(replace_all_occurence) function(STRING_APPEND var_name content) SET(${var_name} "${${var_name}}${content}" PARENT_SCOPE) endfunction(STRING_APPEND var_name content) function(parse_lib_path lib_link lib_directory lib_path) string(REGEX REPLACE "^.*/(lib)?(.*)\\.(so|dll)" "\\2" my_lib_link ${lib_path}) string(REGEX REPLACE "^(.*)/(lib)?(.*)\\.(so|dll)" "\\1" my_lib_dir ${lib_path}) SET(${lib_link} ${my_lib_link} PARENT_SCOPE) SET(${lib_directory} ${my_lib_dir} PARENT_SCOPE) endfunction(parse_lib_path lib_link lib_directory lib_path) srm-ifce-1.18.0/cmake/modules/CMakeGeneratePkgConfig.cmake0000644001662700052000000000646012217066060022263 0ustar adevresscg# @title cmake macro for pkgconfig files generation # @brief generate a .pc package config file with a given name # @author Adrien Devresse include(DefineInstallationPaths REQUIRED) include(CMakeMacroParseArguments REQUIRED) include(CMakeStringHelpers REQUIRED) SET(CMAKE_PKGCONFIG_TEMPLATE "prefix=@PREFIX@ exec_prefix=@PREFIX@ libdir=@LIBDIR_VAR includedir=@INCLUDE_VAR@ Name: @NAME_PROJECT@ Description: @DESCRIPTION_PROJECT@ Version: @VERSION_PROJECT@ URL: @URL_PROJECT@ Requires: @REQUIRES_PROJECT@ Conflicts: @CONFLICTS_PROJECT@ Libs: @LIBS_PROJECT@ Libs.private: @LIBS_PRIVATE_PROJECT@ Cflags: @CFLAGS_PROJECT@ ") SET(CMAKE_PKGCONFIG_TEMPLATE_BASE " prefix=@PREFIX@ exec_prefix= \\\${prefix} libdir= @LIBDIR_VAR@ includedir=@INCLUDE_VAR@ Name: @NAME_PROJECT@ Description: @DESCRIPTION_PROJECT@ Version: @VERSION_PROJECT@ Libs: @LIBS_PROJECT@ Cflags: @CFLAGS_PROJECT@ " ) LIST(APPEND CMAKE_PKGCONFIG_TEMPLATE_BASE_PATTERN "@PREFIX@" "@LIBDIR_VAR@" "@INCLUDE_VAR@" "@NAME_PROJECT@" "@DESCRIPTION_PROJECT@" "@VERSION_PROJECT@" "@LIBS_PROJECT@" "@CFLAGS_PROJECT@") # main function to use # FORMAT : add_PkgConfigFile_for_Library("string_filename.pc" target_library # [DESCRIPTION] "description of the pkgconfig files" # [HEADER_DIRS] dir1, dir2 ) # list of dir to include in $prefix/include/, ex : $prefix/include/dir1 # the pc file is produced in the ${CMAKE_CURRENT_BINARY_DIR} directory function(add_PkgConfigFile_for_Library) PARSE_ARGUMENTS(PKGCONFIGFILE "HEADER_DIRS;DESCRIPTION" "" ${ARGN} ) LIST(GET PKGCONFIGFILE_DEFAULT_ARGS 0 pkgconfig_filename) LIST(GET PKGCONFIGFILE_DEFAULT_ARGS 1 lib_target) LIST(GET PKGCONFIGFILE_DESCRIPTION 0 description) get_target_property(library_name ${lib_target} OUTPUT_NAME) get_target_property(library_version ${lib_target} VERSION) set(pkgconfig_prefix "${CMAKE_INSTALL_PREFIX}") set(pkgconfig_libdir_var "\\\${prefix}/lib${LIB_SUFFIX}") set(pkgconfig_include_var "\\\${prefix}/include") set(pkgconfig_linkflags "-l${library_name} -L\\\${libdir}") set(pkgconfig_name "${pkgconfig_filename}") set(pkgconfig_version "${library_version}") set(pkgconfig_description "pkgconfig file for ${library_name}") IF(PKGCONFIGFILE_HEADER_DIRS) FOREACH(dir ${PKGCONFIGFILE_HEADER_DIRS}) set(pkgconfig_includedir "${pkgconfig_includedir} -I\\\${includedir}/${dir}") ENDFOREACH(dir PKGCONFIGFILE_HEADER_DIRS) ELSE(PKGCONFIGFILE_HEADER_DIRS) set(pkgconfig_includedir " -I\\\${includedir}") ENDIF(PKGCONFIGFILE_HEADER_DIRS) IF(description) set(pkgconfig_description "${description}") ENDIF(description) set(pkgconfig_cflags " ${pkgconfig_includedir} ") LIST(APPEND pkgconfig_list_var ${pkgconfig_prefix} ${pkgconfig_libdir_var} ${pkgconfig_include_var} ${pkgconfig_name} ${pkgconfig_description} ${pkgconfig_version} ${pkgconfig_linkflags} ${pkgconfig_cflags}) replace_all_occurence(pc_file_content ${CMAKE_PKGCONFIG_TEMPLATE_BASE} LIST_PATTERN ${CMAKE_PKGCONFIG_TEMPLATE_BASE_PATTERN} LIST_REPLACER ${pkgconfig_list_var}) SET(filename "${CMAKE_CURRENT_BINARY_DIR}/${pkgconfig_filename}") FILE(WRITE ${filename} "${pc_file_content}" ) message(STATUS "generate pkgconfig file for ${lib_target} under ${filename}") endfunction(add_PkgConfigFile_for_Library)