00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include "fileStageToCache.h"
00011 #include "fileOpr.h"
00012 #include "miscServerFunct.h"
00013 #include "dataObjOpr.h"
00014 #include "physPath.h"
00015
00016
00017
00018 #include "eirods_log.h"
00019 #include "eirods_file_object.h"
00020 #include "eirods_collection_object.h"
00021 #include "eirods_stacktrace.h"
00022 #include "eirods_resource_backport.h"
00023
00024 int
00025 rsFileStageToCache (rsComm_t *rsComm, fileStageSyncInp_t *fileStageToCacheInp)
00026 {
00027 rodsServerHost_t *rodsServerHost;
00028 int remoteFlag;
00029 int status;
00030
00031
00032 eirods::error ret = eirods::get_host_for_hier_string( fileStageToCacheInp->rescHier, remoteFlag, rodsServerHost );
00033 if( !ret.ok() ) {
00034 eirods::log( PASSMSG( "failed in call to eirods::get_host_for_hier_string", ret ) );
00035 return -1;
00036 }
00037
00038 if (remoteFlag < 0) {
00039 return (remoteFlag);
00040 } else {
00041 status = rsFileStageToCacheByHost (rsComm, fileStageToCacheInp,
00042 rodsServerHost);
00043 return (status);
00044 }
00045 }
00046
00047 int
00048 rsFileStageToCacheByHost (rsComm_t *rsComm,
00049 fileStageSyncInp_t *fileStageToCacheInp, rodsServerHost_t *rodsServerHost)
00050 {
00051 int status;
00052 int remoteFlag;
00053
00054 if (rodsServerHost == NULL) {
00055 rodsLog (LOG_NOTICE,
00056 "rsFileStageToCacheByHost: Input NULL rodsServerHost");
00057 return (SYS_INTERNAL_NULL_INPUT_ERR);
00058 }
00059
00060 remoteFlag = rodsServerHost->localFlag;
00061
00062 if (remoteFlag == LOCAL_HOST) {
00063 status = _rsFileStageToCache (rsComm, fileStageToCacheInp);
00064 } else if (remoteFlag == REMOTE_HOST) {
00065 status = remoteFileStageToCache (rsComm, fileStageToCacheInp,
00066 rodsServerHost);
00067 } else {
00068 if (remoteFlag < 0) {
00069 return (remoteFlag);
00070 } else {
00071 rodsLog (LOG_NOTICE,
00072 "rsFileStageToCacheByHost: resolveHost returned value %d",
00073 remoteFlag);
00074 return (SYS_UNRECOGNIZED_REMOTE_FLAG);
00075 }
00076 }
00077
00078 return (status);
00079 }
00080
00081 int
00082 remoteFileStageToCache (rsComm_t *rsComm,
00083 fileStageSyncInp_t *fileStageToCacheInp, rodsServerHost_t *rodsServerHost)
00084 {
00085 int status;
00086
00087 if (rodsServerHost == NULL) {
00088 rodsLog (LOG_NOTICE,
00089 "remoteFileStageToCache: Invalid rodsServerHost");
00090 return SYS_INVALID_SERVER_HOST;
00091 }
00092
00093 if ((status = svrToSvrConnect (rsComm, rodsServerHost)) < 0) {
00094 return status;
00095 }
00096
00097 status = rcFileStageToCache (rodsServerHost->conn, fileStageToCacheInp);
00098
00099 if (status < 0) {
00100 rodsLog (LOG_NOTICE,
00101 "remoteFileStageToCache: rcFileStageToCache failed for %s",
00102 fileStageToCacheInp->filename);
00103 }
00104
00105 return status;
00106 }
00107
00108
00109
00110 int _rsFileStageToCache (rsComm_t *rsComm, fileStageSyncInp_t *fileStageToCacheInp ) {
00111
00112
00113
00114
00115
00116
00117
00118 mkDirForFilePath( rsComm, "/", fileStageToCacheInp->cacheFilename, getDefDirMode() );
00119
00120 if(fileStageToCacheInp->objPath[0] == '\0') {
00121 std::stringstream msg;
00122 msg << __FUNCTION__;
00123 msg << " - Empty logical path.";
00124 eirods::log(LOG_ERROR, msg.str());
00125 return -1;
00126 }
00127
00128
00129
00130 eirods::file_object file_obj( rsComm,
00131 fileStageToCacheInp->objPath,
00132 fileStageToCacheInp->filename, "", 0,
00133 fileStageToCacheInp->mode,
00134 fileStageToCacheInp->flags );
00135 file_obj.resc_hier( fileStageToCacheInp->rescHier );
00136 eirods::error stage_err = fileStageToCache( rsComm,
00137 file_obj,
00138 fileStageToCacheInp->cacheFilename );
00139
00140
00141 if( !stage_err.ok() ) {
00142
00143
00144 if (getErrno ( stage_err.code() ) == EEXIST) {
00145
00146
00147
00148 eirods::collection_object coll_obj( fileStageToCacheInp->cacheFilename, fileStageToCacheInp->rescHier, 0, 0 );
00149 eirods::error rmdir_err = fileRmdir( rsComm, coll_obj );
00150 if( !rmdir_err.ok() ) {
00151 std::stringstream msg;
00152 msg << "fileRmdir failed for [";
00153 msg << fileStageToCacheInp->cacheFilename;
00154 msg << "]";
00155 eirods::error err = PASSMSG( msg.str(), rmdir_err );
00156 eirods::log ( err );
00157 }
00158 } else {
00159 std::stringstream msg;
00160 msg << "fileStageTocache failed for [";
00161 msg << fileStageToCacheInp->filename;
00162 msg << "]";
00163 eirods::error err = PASSMSG( msg.str(), stage_err );
00164 eirods::log ( err );
00165 }
00166
00167
00168
00169 stage_err = fileStageToCache( rsComm,
00170 file_obj,
00171 fileStageToCacheInp->cacheFilename );
00172
00173
00174 if( !stage_err.ok() ) {
00175 std::stringstream msg;
00176 msg << "fileStageTocache for [";
00177 msg << fileStageToCacheInp->filename;
00178 msg << "]";
00179 msg << stage_err.code();
00180 eirods::error err = PASSMSG( msg.str(), stage_err );
00181 eirods::log ( err );
00182 }
00183
00184 }
00185
00186 return (stage_err.code());
00187
00188 }
00189
00190
00191
00192
00193
00194
00195