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