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(
00111 rsComm_t* _comm,
00112 fileStageSyncInp_t* _stage_inp ) {
00113
00114
00115
00116
00117
00118
00119
00120 mkDirForFilePath( _comm, "/", _stage_inp->cacheFilename, getDefDirMode() );
00121
00122 if(_stage_inp->objPath[0] == '\0') {
00123 std::stringstream msg;
00124 msg << __FUNCTION__;
00125 msg << " - Empty logical path.";
00126 eirods::log(LOG_ERROR, msg.str());
00127 return -1;
00128 }
00129
00130
00131
00132 eirods::file_object_ptr file_obj(
00133 new eirods::file_object(
00134 _comm,
00135 _stage_inp->objPath,
00136 _stage_inp->filename, "", 0,
00137 _stage_inp->mode,
00138 _stage_inp->flags ) );
00139 file_obj->resc_hier( _stage_inp->rescHier );
00140 file_obj->size(_stage_inp->dataSize);
00141 eirods::error stage_err = fileStageToCache( _comm,
00142 file_obj,
00143 _stage_inp->cacheFilename );
00144
00145
00146 if( !stage_err.ok() ) {
00147
00148
00149 if (getErrno ( stage_err.code() ) == EEXIST) {
00150
00151
00152
00153 eirods::collection_object_ptr coll_obj(
00154 new eirods::collection_object(
00155 _stage_inp->cacheFilename,
00156 _stage_inp->rescHier,
00157 0, 0 ) );
00158 eirods::error rmdir_err = fileRmdir( _comm, coll_obj );
00159 if( !rmdir_err.ok() ) {
00160 std::stringstream msg;
00161 msg << "fileRmdir failed for [";
00162 msg << _stage_inp->cacheFilename;
00163 msg << "]";
00164 eirods::error err = PASSMSG( msg.str(), rmdir_err );
00165 eirods::log ( err );
00166 }
00167 } else {
00168 eirods::error err = ASSERT_PASS(stage_err, "Failed for \"%s\".", _stage_inp->filename);
00169 eirods::log ( err );
00170 }
00171
00172
00173
00174 stage_err = fileStageToCache( _comm,
00175 file_obj,
00176 _stage_inp->cacheFilename );
00177
00178
00179 if( !stage_err.ok() ) {
00180 std::stringstream msg;
00181 msg << "fileStageTocache for [";
00182 msg << _stage_inp->filename;
00183 msg << "]";
00184 msg << stage_err.code();
00185 eirods::error err = PASSMSG( msg.str(), stage_err );
00186 eirods::log ( err );
00187 }
00188
00189 }
00190
00191 return (stage_err.code());
00192
00193 }
00194
00195
00196
00197
00198
00199
00200