00001
00002
00003 #include "reGlobalsExtern.h"
00004 #include "dataObjChksum.h"
00005 #include "dataObjRsync.h"
00006 #include "objMetaOpr.h"
00007 #include "specColl.h"
00008 #include "dataObjOpr.h"
00009 #include "rsApiHandler.h"
00010 #include "modDataObjMeta.h"
00011 #include "getRemoteZoneResc.h"
00012
00013 #include "eirods_resource_redirect.h"
00014
00015 int
00016 rsDataObjRsync (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00017 msParamArray_t **outParamArray)
00018 {
00019 int status;
00020 char *rsyncMode;
00021 char *remoteZoneOpr;
00022 int remoteFlag;
00023 rodsServerHost_t *rodsServerHost;
00024 specCollCache_t *specCollCache = NULL;
00025
00026 *outParamArray = NULL;
00027 if (dataObjInp == NULL) {
00028 rodsLog(LOG_ERROR, "rsDataObjRsync error. NULL input");
00029 return (SYS_INTERNAL_NULL_INPUT_ERR);
00030 }
00031
00032 rsyncMode = getValByKey (&dataObjInp->condInput, RSYNC_MODE_KW);
00033 if (rsyncMode == NULL) {
00034 rodsLog (LOG_ERROR,
00035 "rsDataObjRsync: RSYNC_MODE_KW input is missing");
00036 return (USER_RSYNC_NO_MODE_INPUT_ERR);
00037 }
00038
00039 if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) {
00040 remoteZoneOpr = REMOTE_CREATE;
00041 } else {
00042 remoteZoneOpr = REMOTE_OPEN;
00043 }
00044
00045 resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
00046 &dataObjInp->condInput);
00047 if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) {
00048 if (isLocalZone (dataObjInp->objPath) == 0) {
00049 dataObjInp_t myDataObjInp;
00050 char *destObjPath;
00051
00052 destObjPath = getValByKey (&dataObjInp->condInput,
00053 RSYNC_DEST_PATH_KW);
00054 if (destObjPath == NULL) {
00055 rodsLog (LOG_ERROR,
00056 "rsDataObjRsync: RSYNC_DEST_PATH_KW input is missing for %s",
00057 dataObjInp->objPath);
00058 return (USER_RSYNC_NO_MODE_INPUT_ERR);
00059 }
00060 myDataObjInp = *dataObjInp;
00061 remoteZoneOpr = REMOTE_CREATE;
00062 rstrcpy (myDataObjInp.objPath, destObjPath, MAX_NAME_LEN);
00063 remoteFlag = getAndConnRemoteZone (rsComm, &myDataObjInp,
00064 &rodsServerHost, remoteZoneOpr);
00065 } else {
00066 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp,
00067 &rodsServerHost, remoteZoneOpr);
00068 }
00069 } else {
00070 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
00071 remoteZoneOpr);
00072 }
00073
00074 if (remoteFlag < 0) {
00075 return (remoteFlag);
00076 } else if (remoteFlag == REMOTE_HOST) {
00077
00078 status = _rcDataObjRsync (rodsServerHost->conn, dataObjInp,
00079 outParamArray);
00080 #if 0
00081 int l1descInx;
00082 if (status < 0) {
00083 return (status);
00084 }
00085
00086 if (status == SYS_SVR_TO_CLI_MSI_REQUEST) {
00087
00088 l1descInx = allocAndSetL1descForZoneOpr (0, dataObjInp,
00089 rodsServerHost, NULL);
00090 if (l1descInx < 0) return l1descInx;
00091 if (*outParamArray == NULL) {
00092 *outParamArray = malloc (sizeof (msParamArray_t));
00093 bzero (*outParamArray, sizeof (msParamArray_t));
00094 }
00095 addIntParamToArray (*outParamArray, CL_ZONE_OPR_INX, l1descInx);
00096 }
00097 #endif
00098 return status;
00099 }
00100
00101 if (strcmp (rsyncMode, IRODS_TO_LOCAL) == 0) {
00102 status = rsRsyncFileToData (rsComm, dataObjInp);
00103 } else if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) {
00104 status = rsRsyncDataToFile (rsComm, dataObjInp);
00105 } else if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) {
00106 status = rsRsyncDataToData (rsComm, dataObjInp);
00107 } else {
00108 rodsLog (LOG_ERROR,
00109 "rsDataObjRsync: rsyncMode %s not supported");
00110 return (USER_RSYNC_NO_MODE_INPUT_ERR);
00111 }
00112
00113 return (status);
00114 }
00115
00116 int
00117 rsRsyncDataToFile (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00118 {
00119 int status;
00120 char *fileChksumStr = NULL;
00121 char *dataObjChksumStr = NULL;
00122 dataObjInfo_t *dataObjInfoHead = NULL;
00123
00124 fileChksumStr = getValByKey (&dataObjInp->condInput, RSYNC_CHKSUM_KW);
00125
00126 if (fileChksumStr == NULL) {
00127 rodsLog (LOG_ERROR,
00128 "rsRsyncDataToFile: RSYNC_CHKSUM_KW input is missing for %s",
00129 dataObjInp->objPath);
00130 return (CHKSUM_EMPTY_IN_STRUCT_ERR);
00131 }
00132
00133 status = _rsDataObjChksum (rsComm, dataObjInp, &dataObjChksumStr,
00134 &dataObjInfoHead);
00135
00136 if (status < 0 && status != CAT_NO_ACCESS_PERMISSION &&
00137 status != CAT_NO_ROWS_FOUND) {
00138
00139
00140
00141 rodsLog (LOG_ERROR,
00142 "rsRsyncDataToFile: _rsDataObjChksum of %s error. status = %d",
00143 dataObjInp->objPath, status);
00144 return (status);
00145 }
00146
00147 freeAllDataObjInfo (dataObjInfoHead);
00148
00149 if (dataObjChksumStr != NULL &&
00150 strcmp (dataObjChksumStr, fileChksumStr) == 0) {
00151 free (dataObjChksumStr);
00152 return (0);
00153 }
00154
00155 return SYS_SVR_TO_CLI_GET_ACTION;
00156 #if 0
00157 msParamArray_t *myMsParamArray;
00158 dataObjInp_t *myDataObjInp;
00159
00160 myMsParamArray = malloc (sizeof (msParamArray_t));
00161 memset (myMsParamArray, 0, sizeof (msParamArray_t));
00162
00163 myDataObjInp = malloc (sizeof (dataObjInp_t));
00164 replDataObjInp (dataObjInp, myDataObjInp);
00165
00166 status = addMsParam (myMsParamArray, CL_GET_ACTION, DataObjInp_MS_T,
00167 (void *) myDataObjInp, NULL);
00168
00169 if (status < 0) {
00170 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, status,
00171 "rsRsyncDataToFile: addMsParam error. status = %d", status);
00172 return (status);
00173 }
00174
00175
00176 status = sendAndRecvBranchMsg (rsComm, rsComm->apiInx,
00177 SYS_SVR_TO_CLI_MSI_REQUEST, (void *) myMsParamArray, NULL);
00178
00179 return (status);
00180 #endif
00181 }
00182
00183 int
00184 rsRsyncFileToData (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00185 {
00186 int status;
00187 char *fileChksumStr = NULL;
00188 char *dataObjChksumStr = NULL;
00189 dataObjInfo_t *dataObjInfoHead = NULL;
00190
00191 fileChksumStr = getValByKey (&dataObjInp->condInput, RSYNC_CHKSUM_KW);
00192
00193 if (fileChksumStr == NULL) {
00194 rodsLog (LOG_ERROR,
00195 "rsRsyncFileToData: RSYNC_CHKSUM_KW input is missing");
00196 return (CHKSUM_EMPTY_IN_STRUCT_ERR);
00197 }
00198
00199
00200
00201 if( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
00202 std::string hier;
00203 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_OPEN_OPERATION,
00204 rsComm, dataObjInp, hier );
00205 if( !ret.ok() ) {
00206 std::stringstream msg;
00207 msg << __FUNCTION__;
00208 msg << " :: failed in eirods::resolve_resource_hierarchy for [";
00209 msg << dataObjInp->objPath << "]";
00210 eirods::log( PASSMSG( msg.str(), ret ) );
00211 return ret.code();
00212 }
00213
00214
00215
00216
00217 addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00218
00219 }
00220
00221 status = _rsDataObjChksum (rsComm, dataObjInp, &dataObjChksumStr,
00222 &dataObjInfoHead);
00223
00224 if (status < 0 && status != CAT_NO_ACCESS_PERMISSION &&
00225 status != CAT_NO_ROWS_FOUND) {
00226
00227
00228
00229 rodsLog (LOG_ERROR,
00230 "rsRsyncFileToData: _rsDataObjChksum of %s error. status = %d",
00231 dataObjInp->objPath, status);
00232 }
00233
00234 freeAllDataObjInfo (dataObjInfoHead);
00235
00236 if (dataObjChksumStr != NULL &&
00237 strcmp (dataObjChksumStr, fileChksumStr) == 0) {
00238 free (dataObjChksumStr);
00239 return (0);
00240 }
00241 return SYS_SVR_TO_CLI_PUT_ACTION;
00242 #if 0
00243 msParamArray_t *myMsParamArray;
00244 dataObjInp_t *myDataObjInp;
00245
00246 myMsParamArray = malloc (sizeof (msParamArray_t));
00247 memset (myMsParamArray, 0, sizeof (msParamArray_t));
00248
00249 myDataObjInp = malloc (sizeof (dataObjInp_t));
00250 replDataObjInp (dataObjInp, myDataObjInp);
00251 addKeyVal (&myDataObjInp->condInput, REG_CHKSUM_KW, fileChksumStr);
00252
00253 status = addMsParam (myMsParamArray, CL_PUT_ACTION, DataObjInp_MS_T,
00254 (void *) myDataObjInp, NULL);
00255
00256 if (status < 0) {
00257 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, status,
00258 "rsRsyncDataToFile: addMsParam error. status = %d", status);
00259 return (status);
00260 }
00261
00262
00263 status = sendAndRecvBranchMsg (rsComm, rsComm->apiInx,
00264 SYS_SVR_TO_CLI_MSI_REQUEST, (void *) myMsParamArray, NULL);
00265
00266 return (status);
00267 #endif
00268 }
00269
00270 int
00271 rsRsyncDataToData (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00272 {
00273 int status;
00274 char *srcChksumStr = NULL;
00275 char *destChksumStr = NULL;
00276 #if 0
00277 dataObjInfo_t *srcDataObjInfoHead = NULL;
00278 dataObjInfo_t *destDataObjInfoHead = NULL;
00279 #endif
00280 dataObjCopyInp_t dataObjCopyInp;
00281 char *destObjPath;
00282 transferStat_t *transStat = NULL;
00283
00284
00285 addKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW, "");
00286
00287 destObjPath = getValByKey (&dataObjInp->condInput, RSYNC_DEST_PATH_KW);
00288 if (destObjPath == NULL) {
00289 rodsLog (LOG_ERROR,
00290 "rsRsyncDataToData: RSYNC_DEST_PATH_KW input is missing for %s",
00291 dataObjInp->objPath);
00292 return (USER_RSYNC_NO_MODE_INPUT_ERR);
00293 }
00294
00295 memset (&dataObjCopyInp, 0, sizeof (dataObjCopyInp));
00296 rstrcpy (dataObjCopyInp.srcDataObjInp.objPath, dataObjInp->objPath,
00297 MAX_NAME_LEN);
00298 dataObjCopyInp.srcDataObjInp.dataSize = dataObjInp->dataSize;
00299 replDataObjInp (dataObjInp, &dataObjCopyInp.destDataObjInp);
00300 rstrcpy (dataObjCopyInp.destDataObjInp.objPath, destObjPath,
00301 MAX_NAME_LEN);
00302
00303
00304 status = rsDataObjChksum (rsComm, &dataObjCopyInp.srcDataObjInp,
00305 &srcChksumStr);
00306
00307 if (status < 0 &&
00308 (status != CAT_NO_ACCESS_PERMISSION || srcChksumStr == NULL)) {
00309
00310
00311
00312 rodsLog (LOG_ERROR,
00313 "rsRsyncDataToData: _rsDataObjChksum error for %s, status = %d",
00314 dataObjCopyInp.srcDataObjInp.objPath, status);
00315 clearKeyVal (&dataObjCopyInp.destDataObjInp.condInput);
00316 return (status);
00317 }
00318
00319
00320 status = rsDataObjChksum (rsComm, &dataObjCopyInp.destDataObjInp,
00321 &destChksumStr);
00322
00323 if (status < 0 && status != CAT_NO_ACCESS_PERMISSION &&
00324 status != CAT_NO_ROWS_FOUND) {
00325 rodsLog (LOG_ERROR,
00326 "rsRsyncDataToData: _rsDataObjChksum error for %s, status = %d",
00327 dataObjCopyInp.destDataObjInp.objPath, status);
00328 clearKeyVal (&dataObjCopyInp.destDataObjInp.condInput);
00329 return (status);
00330 }
00331
00332 if (destChksumStr != NULL && strcmp (srcChksumStr, destChksumStr) == 0) {
00333 free (srcChksumStr);
00334 free (destChksumStr);
00335 clearKeyVal (&dataObjCopyInp.destDataObjInp.condInput);
00336 clearKeyVal (&dataObjCopyInp.srcDataObjInp.condInput);
00337 return (0);
00338 }
00339
00340 addKeyVal (&dataObjCopyInp.destDataObjInp.condInput, REG_CHKSUM_KW,
00341 srcChksumStr);
00342 status = rsDataObjCopy (rsComm, &dataObjCopyInp, &transStat);
00343 if (transStat != NULL) {
00344 free (transStat);
00345 }
00346 free (srcChksumStr);
00347 if (destChksumStr != NULL)
00348 free (destChksumStr);
00349 clearKeyVal (&dataObjCopyInp.destDataObjInp.condInput);
00350 clearKeyVal (&dataObjCopyInp.srcDataObjInp.condInput);
00351
00352 if (status >= 0) {
00353 return SYS_RSYNC_TARGET_MODIFIED;
00354 } else {
00355 return status;
00356 }
00357 }
00358