00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include "dataObjClose.h"
00012 #include "rodsLog.h"
00013 #include "regReplica.h"
00014 #include "modDataObjMeta.h"
00015 #include "dataObjOpr.h"
00016 #include "objMetaOpr.h"
00017 #include "physPath.h"
00018 #include "resource.h"
00019 #include "dataObjUnlink.h"
00020 #include "rsGlobalExtern.h"
00021 #include "rcGlobalExtern.h"
00022 #include "reGlobalsExtern.h"
00023 #include "reDefines.h"
00024 #include "ruleExecSubmit.h"
00025 #include "subStructFileRead.h"
00026 #include "subStructFileStat.h"
00027 #include "subStructFileClose.h"
00028 #include "regDataObj.h"
00029 #include "dataObjRepl.h"
00030 #include "dataObjTrim.h"
00031 #include "dataObjLock.h"
00032 #include "getRescQuota.h"
00033
00034 #ifdef LOG_TRANSFERS
00035 #include <sys/time.h>
00036 #include <sys/socket.h>
00037 #include <netinet/in.h>
00038 #include <arpa/inet.h>
00039 #endif
00040
00041
00042
00043 #include "eirods_resource_backport.h"
00044 #include "eirods_stacktrace.h"
00045 #include "eirods_hierarchy_parser.h"
00046 #include "eirods_file_object.h"
00047
00048
00049 int
00050 rsDataObjClose (rsComm_t *rsComm, openedDataObjInp_t *dataObjCloseInp)
00051 {
00052 int status;
00053
00054 dataObjInfo_t* data_obj = 0;
00055 status = irsDataObjClose( rsComm, dataObjCloseInp, &data_obj );
00056
00057 if( !data_obj ) {
00058 rodsLog( LOG_ERROR, "rsDataObjClose data_obj is null" );
00059 return status;
00060 }
00061
00062 return status;
00063 }
00064
00065 int
00066 irsDataObjClose (
00067 rsComm_t *rsComm,
00068 openedDataObjInp_t *dataObjCloseInp,
00069 dataObjInfo_t **outDataObjInfo)
00070 {
00071 int status;
00072 int srcL1descInx;
00073 openedDataObjInp_t myDataObjCloseInp;
00074 int l1descInx;
00075 ruleExecInfo_t rei;
00076 #ifdef TEST_QUE_RULE
00077 bytesBuf_t *packedReiAndArgBBuf = NULL;;
00078 ruleExecSubmitInp_t ruleExecSubmitInp;
00079 #endif
00080 l1descInx = dataObjCloseInp->l1descInx;
00081 if (l1descInx <= 2 || l1descInx >= NUM_L1_DESC) {
00082 rodsLog (LOG_NOTICE,
00083 "rsDataObjClose: l1descInx %d out of range",
00084 l1descInx);
00085 return (SYS_FILE_DESC_OUT_OF_RANGE);
00086 }
00087
00088 if (outDataObjInfo != NULL) *outDataObjInfo = NULL;
00089 if (L1desc[l1descInx].remoteZoneHost != NULL) {
00090
00091 dataObjCloseInp->l1descInx = L1desc[l1descInx].remoteL1descInx;
00092
00093
00094
00095 status = rcDataObjClose (L1desc[l1descInx].remoteZoneHost->conn, dataObjCloseInp);
00096 dataObjCloseInp->l1descInx = l1descInx;
00097 } else {
00098 status = _rsDataObjClose (rsComm, dataObjCloseInp);
00099
00100
00101 if (L1desc[l1descInx].lockFd > 0) {
00102 rsDataObjUnlock (rsComm, L1desc[l1descInx].dataObjInp, L1desc[l1descInx].lockFd);
00103 L1desc[l1descInx].lockFd = -1;
00104 }
00105
00106
00107 if (status >= 0 && L1desc[l1descInx].oprStatus >= 0) {
00108
00109
00110 if (L1desc[l1descInx].openType == CREATE_TYPE) {
00111 initReiWithDataObjInp (&rei, rsComm,
00112 L1desc[l1descInx].dataObjInp);
00113 rei.doi = L1desc[l1descInx].dataObjInfo;
00114 rei.status = status;
00115 rei.status = applyRule ("acPostProcForCreate", NULL, &rei,
00116 NO_SAVE_REI);
00117
00118 L1desc[l1descInx].dataObjInfo = rei.doi;
00119 } else if (L1desc[l1descInx].openType == OPEN_FOR_READ_TYPE ||
00120 L1desc[l1descInx].openType == OPEN_FOR_WRITE_TYPE) {
00121 initReiWithDataObjInp (&rei, rsComm,
00122 L1desc[l1descInx].dataObjInp);
00123 rei.doi = L1desc[l1descInx].dataObjInfo;
00124 rei.status = status;
00125 rei.status = applyRule ("acPostProcForOpen", NULL, &rei,
00126 NO_SAVE_REI);
00127
00128 L1desc[l1descInx].dataObjInfo = rei.doi;
00129
00130
00131 } else if (L1desc[l1descInx].oprType == REPLICATE_DEST) {
00132 initReiWithDataObjInp (&rei, rsComm,
00133 L1desc[l1descInx].dataObjInp);
00134 rei.doi = L1desc[l1descInx].dataObjInfo;
00135 rei.status = status;
00136 rei.status = applyRule ("acPostProcForRepl", NULL, &rei,
00137 NO_SAVE_REI);
00138
00139 L1desc[l1descInx].dataObjInfo = rei.doi;
00140
00141 }
00142
00143 if (L1desc[l1descInx].oprType == COPY_DEST) {
00144
00145
00146 initReiWithDataObjInp (&rei, rsComm,
00147 L1desc[l1descInx].dataObjInp);
00148 rei.doi = L1desc[l1descInx].dataObjInfo;
00149 rei.status = status;
00150 rei.status = applyRule ("acPostProcForCopy", NULL, &rei,
00151 NO_SAVE_REI);
00152
00153 L1desc[l1descInx].dataObjInfo = rei.doi;
00154 } else if (L1desc[l1descInx].oprType == PUT_OPR ||
00155 L1desc[l1descInx].openType == CREATE_TYPE ||
00156 (L1desc[l1descInx].openType == OPEN_FOR_WRITE_TYPE &&
00157 (L1desc[l1descInx].bytesWritten > 0 ||
00158 dataObjCloseInp->bytesWritten > 0))) {
00159 initReiWithDataObjInp (&rei, rsComm,
00160 L1desc[l1descInx].dataObjInp);
00161 rei.doi = L1desc[l1descInx].dataObjInfo;
00162 #ifdef TEST_QUE_RULE
00163 status = packReiAndArg (rsComm, &rei, NULL, 0,
00164 &packedReiAndArgBBuf);
00165 if (status < 0) {
00166 rodsLog (LOG_ERROR,
00167 "rsDataObjClose: packReiAndArg error");
00168 } else {
00169 memset (&ruleExecSubmitInp, 0, sizeof (ruleExecSubmitInp));
00170 rstrcpy (ruleExecSubmitInp.ruleName, "acPostProcForPut",
00171 NAME_LEN);
00172 rstrcpy (ruleExecSubmitInp.userName, rei.uoic->userName,
00173 NAME_LEN);
00174 ruleExecSubmitInp.packedReiAndArgBBuf = packedReiAndArgBBuf;
00175 getNowStr (ruleExecSubmitInp.exeTime);
00176 status = rsRuleExecSubmit (rsComm, &ruleExecSubmitInp);
00177 free (packedReiAndArgBBuf);
00178 if (status < 0) {
00179 rodsLog (LOG_ERROR,
00180 "rsDataObjClose: rsRuleExecSubmit failed");
00181 }
00182 }
00183 #else
00184 rei.status = status;
00185 rei.status = applyRule ("acPostProcForPut", NULL, &rei,
00186 NO_SAVE_REI);
00187
00188 L1desc[l1descInx].dataObjInfo = rei.doi;
00189 #endif
00190 } else if (L1desc[l1descInx].dataObjInp != NULL &&
00191 L1desc[l1descInx].dataObjInp->oprType == PHYMV_OPR) {
00192 initReiWithDataObjInp (&rei, rsComm,
00193 L1desc[l1descInx].dataObjInp);
00194 rei.doi = L1desc[l1descInx].dataObjInfo;
00195 rei.status = status;
00196 rei.status = applyRule ("acPostProcForPhymv", NULL, &rei,
00197 NO_SAVE_REI);
00198
00199 L1desc[l1descInx].dataObjInfo = rei.doi;
00200
00201 }
00202 }
00203 }
00204
00205 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00206 if ((L1desc[l1descInx].oprType == REPLICATE_DEST ||
00207 L1desc[l1descInx].oprType == COPY_DEST) &&
00208 srcL1descInx > 2) {
00209 memset (&myDataObjCloseInp, 0, sizeof (myDataObjCloseInp));
00210 myDataObjCloseInp.l1descInx = srcL1descInx;
00211 rsDataObjClose (rsComm, &myDataObjCloseInp);
00212 }
00213
00214 if (outDataObjInfo != NULL) {
00215 *outDataObjInfo = L1desc[l1descInx].dataObjInfo;
00216 L1desc[l1descInx].dataObjInfo = NULL;
00217 }
00218
00219 freeL1desc (l1descInx);
00220
00221 return (status);
00222 }
00223
00224 #ifdef LOG_TRANSFERS
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239 int
00240 logTransfer (char *oprType, char *objPath, rodsLong_t fileSize,
00241 struct timeval *startTime, char *rescName, char *userName,
00242 char *hostName)
00243 {
00244 struct timeval diffTime;
00245 char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
00246 float transRate, sizeInMb, timeInSec;
00247 int status;
00248 struct timeval endTime;
00249
00250 (void)gettimeofday(&endTime, (struct timezone *)0);
00251
00252
00253 if ((status = splitPathByKey (objPath, myDir, myFile, '/')) < 0) {
00254 rodsLogError (LOG_NOTICE, status,
00255 "printTiming: splitPathByKey for %s error, status = %d",
00256 objPath, status);
00257 return (status);
00258 }
00259
00260 diffTime.tv_sec = endTime.tv_sec - startTime->tv_sec;
00261 diffTime.tv_usec = endTime.tv_usec - startTime->tv_usec;
00262
00263 if (diffTime.tv_usec < 0) {
00264 diffTime.tv_sec --;
00265 diffTime.tv_usec += 1000000;
00266 }
00267
00268 timeInSec = (float) diffTime.tv_sec + ((float) diffTime.tv_usec /
00269 1000000.0);
00270
00271 if (fileSize <= 0) {
00272 transRate = 0.0;
00273 sizeInMb = 0.0;
00274 } else {
00275 sizeInMb = (float) fileSize / 1048600.0;
00276 if (timeInSec == 0.0) {
00277 transRate = 0.0;
00278 } else {
00279 transRate = sizeInMb / timeInSec;
00280 }
00281 }
00282
00283 if (fileSize < 0) {
00284 rodsLog (LOG_NOTICE, "Transfer %.3f sec %s %s %s %s %s\n",
00285 timeInSec, oprType, rescName, objPath, hostName);
00286 } else {
00287 rodsLog (LOG_NOTICE, "Transfer %10.3f MB | %.3f sec | %6.3f MB/s %s %s %s %s %s\n",
00288 sizeInMb, timeInSec, transRate, oprType, rescName,
00289 objPath, userName, hostName);
00290 }
00291 return (0);
00292 }
00293 #endif
00294
00295 int
00296 _rsDataObjClose (
00297 rsComm_t *rsComm,
00298 openedDataObjInp_t *dataObjCloseInp)
00299 {
00300 int status = 0;
00301 int l1descInx, l3descInx;
00302 keyValPair_t regParam;
00303 rodsLong_t newSize;
00304 char tmpStr[MAX_NAME_LEN];
00305 modDataObjMeta_t modDataObjMetaInp;
00306 char *chksumStr = NULL;
00307 dataObjInfo_t *destDataObjInfo, *srcDataObjInfo;
00308 int srcL1descInx;
00309 regReplica_t regReplicaInp;
00310 int noChkCopyLenFlag;
00311
00312 l1descInx = dataObjCloseInp->l1descInx;
00313 l3descInx = L1desc[l1descInx].l3descInx;
00314
00315 if (l3descInx > 2) {
00316
00317 status = l3Close (rsComm, l1descInx);
00318
00319 if (status < 0) {
00320 rodsLog (LOG_NOTICE,
00321 "_rsDataObjClose: l3Close of %d failed, status = %d",
00322 l3descInx, status);
00323 return (status);
00324 }
00325 }
00326
00327 if (L1desc[l1descInx].oprStatus < 0) {
00328
00329 return L1desc[l1descInx].oprStatus;
00330 }
00331
00332 if (dataObjCloseInp->bytesWritten > 0 &&
00333 L1desc[l1descInx].bytesWritten <= 0) {
00334
00335
00336 L1desc[l1descInx].bytesWritten =
00337 dataObjCloseInp->bytesWritten;
00338 }
00339
00340
00341
00342 if (L1desc[l1descInx].bytesWritten <= 0 &&
00343 L1desc[l1descInx].oprType != REPLICATE_DEST &&
00344 L1desc[l1descInx].oprType != PHYMV_DEST &&
00345 L1desc[l1descInx].oprType != COPY_DEST) {
00346
00347
00348
00349 if (L1desc[l1descInx].purgeCacheFlag > 0) {
00350 int status1 = trimDataObjInfo (rsComm,
00351 L1desc[l1descInx].dataObjInfo);
00352 if (status1 < 0) {
00353 rodsLogError (LOG_ERROR, status1,
00354 "_rsDataObjClose: trimDataObjInfo error for %s",
00355 L1desc[l1descInx].dataObjInfo->objPath);
00356 }
00357 }
00358
00359 #ifdef LOG_TRANSFERS
00360 if (L1desc[l1descInx].oprType == GET_OPR) {
00361 logTransfer("get", L1desc[l1descInx].dataObjInfo->objPath,
00362 L1desc[l1descInx].dataObjInfo->dataSize,
00363 &L1desc[l1descInx].openStartTime,
00364 L1desc[l1descInx].dataObjInfo->rescName,
00365 rsComm->clientUser.userName,
00366 inet_ntoa (rsComm->remoteAddr.sin_addr));
00367 }
00368 #endif
00369 return (status);
00370 }
00371
00372 if (getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00373 NO_CHK_COPY_LEN_KW) != NULL) {
00374 noChkCopyLenFlag = 1;
00375 } else {
00376 noChkCopyLenFlag = 0;
00377 }
00378 if (L1desc[l1descInx].stageFlag == NO_STAGING) {
00379
00380
00381 newSize = getSizeInVault (rsComm, L1desc[l1descInx].dataObjInfo);
00382
00383
00384
00385 if (newSize < 0) {
00386 status = (int) newSize;
00387 rodsLog (LOG_ERROR,
00388 "_rsDataObjClose: getSizeInVault error for %s, status = %d",
00389 L1desc[l1descInx].dataObjInfo->objPath, status);
00390 return (status);
00391 } else if (L1desc[l1descInx].dataSize > 0) {
00392 if (newSize != L1desc[l1descInx].dataSize &&
00393 noChkCopyLenFlag == 0) {
00394 rodsLog (LOG_NOTICE,
00395 "_rsDataObjClose: size in vault %lld != target size %lld",
00396 newSize, L1desc[l1descInx].dataSize);
00397 return (SYS_COPY_LEN_ERR);
00398 }
00399 }
00400 } else {
00401
00402
00403 newSize = L1desc[l1descInx].dataSize;
00404 }
00405
00406 if (noChkCopyLenFlag == 0) {
00407 status = procChksumForClose (rsComm, l1descInx, &chksumStr);
00408 if (status < 0) {
00409 return status;
00410 }
00411 }
00412
00413 memset (®Param, 0, sizeof (regParam));
00414 if (L1desc[l1descInx].oprType == PHYMV_DEST) {
00415
00416 destDataObjInfo = L1desc[l1descInx].dataObjInfo;
00417 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00418 if (srcL1descInx <= 2) {
00419 rodsLog (LOG_NOTICE,
00420 "_rsDataObjClose: srcL1descInx %d out of range",
00421 srcL1descInx);
00422 return (SYS_FILE_DESC_OUT_OF_RANGE);
00423 }
00424 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00425
00426 if (chksumStr != NULL) {
00427 addKeyVal (®Param, CHKSUM_KW, chksumStr);
00428 }
00429 addKeyVal (®Param, FILE_PATH_KW, destDataObjInfo->filePath);
00430 addKeyVal (®Param, RESC_NAME_KW, destDataObjInfo->rescName);
00431 addKeyVal (®Param, RESC_HIER_STR_KW, destDataObjInfo->rescHier);
00432 addKeyVal (®Param, RESC_GROUP_NAME_KW,
00433 destDataObjInfo->rescGroupName);
00434 if (getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00435 IRODS_ADMIN_KW) != NULL) {
00436 addKeyVal (®Param, IRODS_ADMIN_KW, "");
00437 }
00438 char* pdmo_kw = getValByKey(&dataObjCloseInp->condInput, IN_PDMO_KW);
00439 if(pdmo_kw != NULL) {
00440 addKeyVal(®Param, IN_PDMO_KW, pdmo_kw);
00441 }
00442 modDataObjMetaInp.dataObjInfo = destDataObjInfo;
00443 modDataObjMetaInp.regParam = ®Param;
00444 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00445 clearKeyVal (®Param);
00446
00447
00448 if (status >= 0) {
00449 if (L1desc[srcL1descInx].l3descInx > 2) {
00450 int status1;
00451 status1 = l3Close (rsComm, srcL1descInx);
00452 if (status1 < 0) {
00453 rodsLog (LOG_NOTICE,
00454 "_rsDataObjClose: l3Close of %s error. status = %d",
00455 srcDataObjInfo->objPath, status1);
00456 }
00457 }
00458 l3Unlink (rsComm, srcDataObjInfo);
00459 updatequotaOverrun (destDataObjInfo->rescInfo,
00460 destDataObjInfo->dataSize, RESC_QUOTA);
00461 } else {
00462 if (L1desc[srcL1descInx].l3descInx > 2)
00463 l3Close (rsComm, srcL1descInx);
00464 }
00465 freeL1desc (srcL1descInx);
00466 L1desc[l1descInx].srcL1descInx = 0;
00467 } else if (L1desc[l1descInx].oprType == REPLICATE_DEST) {
00468 destDataObjInfo = L1desc[l1descInx].dataObjInfo;
00469 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00470 if (srcL1descInx <= 2) {
00471 rodsLog (LOG_NOTICE,
00472 "_rsDataObjClose: srcL1descInx %d out of range",
00473 srcL1descInx);
00474 return (SYS_FILE_DESC_OUT_OF_RANGE);
00475 }
00476 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00477
00478 if (L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) {
00479
00480
00481 snprintf (tmpStr, MAX_NAME_LEN, "%d", srcDataObjInfo->replStatus);
00482 addKeyVal (®Param, REPL_STATUS_KW, tmpStr);
00483 snprintf (tmpStr, MAX_NAME_LEN, "%lld", srcDataObjInfo->dataSize);
00484 addKeyVal (®Param, DATA_SIZE_KW, tmpStr);
00485 snprintf (tmpStr, MAX_NAME_LEN, "%d", (int) time (NULL));
00486 addKeyVal (®Param, DATA_MODIFY_KW, tmpStr);
00487 if (chksumStr != NULL) {
00488 addKeyVal (®Param, CHKSUM_KW, chksumStr);
00489 }
00490
00491 if (getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00492 IRODS_ADMIN_KW) != NULL) {
00493 addKeyVal (®Param, IRODS_ADMIN_KW, "");
00494 }
00495 if ((L1desc[l1descInx].replStatus & FILE_PATH_HAS_CHG) != 0) {
00496
00497 addKeyVal (®Param, FILE_PATH_KW, destDataObjInfo->filePath);
00498 }
00499 char* pdmo_kw = getValByKey(&dataObjCloseInp->condInput, IN_PDMO_KW);
00500 if(pdmo_kw != NULL) {
00501 addKeyVal(®Param, IN_PDMO_KW, pdmo_kw);
00502 }
00503 modDataObjMetaInp.dataObjInfo = destDataObjInfo;
00504 modDataObjMetaInp.regParam = ®Param;
00505 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00506 } else {
00507
00508 memset (®ReplicaInp, 0, sizeof (regReplicaInp));
00509 if (destDataObjInfo->dataId <= 0)
00510 destDataObjInfo->dataId = srcDataObjInfo->dataId;
00511 regReplicaInp.srcDataObjInfo = srcDataObjInfo;
00512 regReplicaInp.destDataObjInfo = destDataObjInfo;
00513 if (getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00514 SU_CLIENT_USER_KW) != NULL) {
00515 addKeyVal (®ReplicaInp.condInput, SU_CLIENT_USER_KW, "");
00516 addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, "");
00517 } else if (getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00518 IRODS_ADMIN_KW) != NULL) {
00519 addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, "");
00520 }
00521
00522 char* pdmo_kw = getValByKey(&dataObjCloseInp->condInput, IN_PDMO_KW);
00523 if( pdmo_kw ) {
00524 addKeyVal( ®ReplicaInp.condInput, IN_PDMO_KW, pdmo_kw );
00525 }
00526
00527 status = rsRegReplica (rsComm, ®ReplicaInp);
00528 clearKeyVal (®ReplicaInp.condInput);
00529
00530 updatequotaOverrun (destDataObjInfo->rescInfo,
00531 destDataObjInfo->dataSize, ALL_QUOTA);
00532 }
00533 if (chksumStr != NULL) {
00534 free (chksumStr);
00535 chksumStr = NULL;
00536 }
00537
00538 clearKeyVal (®Param);
00539
00540 if (status < 0) {
00541 L1desc[l1descInx].oprStatus = status;
00542
00543
00544
00545 if (status != CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME)
00546 l3Unlink (rsComm, L1desc[l1descInx].dataObjInfo);
00547
00548 rodsLog( LOG_NOTICE,
00549 "_rsDataObjClose: RegReplica/ModDataObjMeta %s err. stat = %d",
00550 destDataObjInfo->objPath, status );
00551 return (status);
00552 }
00553 } else if (L1desc[l1descInx].dataObjInfo->specColl == NULL) {
00554
00555 if (l3descInx < 2 &&
00556 getValByKey (&L1desc[l1descInx].dataObjInp->condInput,
00557 CROSS_ZONE_CREATE_KW) != NULL &&
00558 L1desc[l1descInx].replStatus == NEWLY_CREATED_COPY) {
00559
00560
00561 status = svrRegDataObj (rsComm, L1desc[l1descInx].dataObjInfo);
00562 if (status < 0) {
00563 L1desc[l1descInx].oprStatus = status;
00564 rodsLog (LOG_NOTICE,
00565 "_rsDataObjClose: svrRegDataObj for %s failed, status = %d",
00566 L1desc[l1descInx].dataObjInfo->objPath, status);
00567 }
00568 }
00569
00570 if (L1desc[l1descInx].dataObjInfo == NULL ||
00571 L1desc[l1descInx].dataObjInfo->dataSize != newSize) {
00572 snprintf (tmpStr, MAX_NAME_LEN, "%lld", newSize);
00573 addKeyVal (®Param, DATA_SIZE_KW, tmpStr);
00574
00575 L1desc[l1descInx].dataObjInfo->dataSize = newSize;
00576 }
00577
00578 if (chksumStr != NULL) {
00579 addKeyVal (®Param, CHKSUM_KW, chksumStr);
00580 }
00581
00582 if (L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) {
00583 addKeyVal (®Param, ALL_REPL_STATUS_KW, tmpStr);
00584 snprintf (tmpStr, MAX_NAME_LEN, "%d", (int) time (NULL));
00585 addKeyVal (®Param, DATA_MODIFY_KW, tmpStr);
00586 } else {
00587 snprintf (tmpStr, MAX_NAME_LEN, "%d", NEWLY_CREATED_COPY);
00588 addKeyVal (®Param, REPL_STATUS_KW, tmpStr);
00589 }
00590 modDataObjMetaInp.dataObjInfo = L1desc[l1descInx].dataObjInfo;
00591 modDataObjMetaInp.regParam = ®Param;
00592
00593 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00594
00595 if (chksumStr != NULL) {
00596 free (chksumStr);
00597 chksumStr = NULL;
00598 }
00599
00600 clearKeyVal (®Param);
00601
00602 if (status < 0) {
00603 return (status);
00604 }
00605 if (L1desc[l1descInx].replStatus == NEWLY_CREATED_COPY) {
00606
00607 updatequotaOverrun (L1desc[l1descInx].dataObjInfo->rescInfo,
00608 newSize, ALL_QUOTA);
00609 }
00610 }
00611
00612 if (chksumStr != NULL) {
00613 free (chksumStr);
00614 chksumStr = NULL;
00615 }
00616
00617
00618
00619
00620 if (L1desc[l1descInx].purgeCacheFlag > 0) {
00621 int status1 = trimDataObjInfo (rsComm,
00622 L1desc[l1descInx].dataObjInfo);
00623 if (status1 < 0) {
00624 rodsLogError (LOG_ERROR, status1,
00625 "_rsDataObjClose: trimDataObjInfo error for %s",
00626 L1desc[l1descInx].dataObjInfo->objPath);
00627 }
00628 }
00629
00630
00631
00632
00633 L1desc[l1descInx].bytesWritten =
00634 L1desc[l1descInx].dataObjInfo->dataSize = newSize;
00635
00636 #ifdef LOG_TRANSFERS
00637
00638 if (L1desc[l1descInx].oprType == PUT_OPR ||
00639 L1desc[l1descInx].oprType == CREATE_OPR) {
00640 logTransfer("put", L1desc[l1descInx].dataObjInfo->objPath,
00641 L1desc[l1descInx].dataObjInfo->dataSize,
00642 &L1desc[l1descInx].openStartTime,
00643 L1desc[l1descInx].dataObjInfo->rescName,
00644 rsComm->clientUser.userName,
00645 inet_ntoa (rsComm->remoteAddr.sin_addr));
00646
00647 }
00648 if (L1desc[l1descInx].oprType == GET_OPR) {
00649 logTransfer("get", L1desc[l1descInx].dataObjInfo->objPath,
00650 L1desc[l1descInx].dataObjInfo->dataSize,
00651 &L1desc[l1descInx].openStartTime,
00652 L1desc[l1descInx].dataObjInfo->rescName,
00653 rsComm->clientUser.userName,
00654 inet_ntoa (rsComm->remoteAddr.sin_addr));
00655 }
00656 if (L1desc[l1descInx].oprType == REPLICATE_OPR ||
00657 L1desc[l1descInx].oprType == REPLICATE_DEST) {
00658 logTransfer("replicate", L1desc[l1descInx].dataObjInfo->objPath,
00659 L1desc[l1descInx].dataObjInfo->dataSize,
00660 &L1desc[l1descInx].openStartTime,
00661 L1desc[l1descInx].dataObjInfo->rescName,
00662 rsComm->clientUser.userName,
00663 inet_ntoa (rsComm->remoteAddr.sin_addr));
00664 }
00665
00666 if (L1desc[l1descInx].oprType == RSYNC_OPR) {
00667 logTransfer("rsync", L1desc[l1descInx].dataObjInfo->objPath,
00668 L1desc[l1descInx].dataObjInfo->dataSize,
00669 &L1desc[l1descInx].openStartTime,
00670 L1desc[l1descInx].dataObjInfo->rescName,
00671 rsComm->clientUser.userName,
00672 inet_ntoa (rsComm->remoteAddr.sin_addr));
00673 }
00674 #endif
00675
00676 return (status);
00677 }
00678
00679 int
00680 l3Close (rsComm_t *rsComm, int l1descInx)
00681 {
00682 fileCloseInp_t fileCloseInp;
00683 int status;
00684
00685 dataObjInfo_t *dataObjInfo;
00686 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00687
00688 std::string location;
00689 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00690 if( !ret.ok() ) {
00691 eirods::log( PASSMSG( "failed in get_loc_for_hier_string", ret ) );
00692 return -1;
00693 }
00694
00695
00696 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00697 subStructFileFdOprInp_t subStructFileCloseInp;
00698 memset (&subStructFileCloseInp, 0, sizeof (subStructFileCloseInp));
00699 subStructFileCloseInp.type = dataObjInfo->specColl->type;
00700 subStructFileCloseInp.fd = L1desc[l1descInx].l3descInx;
00701 rstrcpy (subStructFileCloseInp.addr.hostAddr, location.c_str(), NAME_LEN);
00702 status = rsSubStructFileClose (rsComm, &subStructFileCloseInp);
00703 } else {
00704 memset (&fileCloseInp, 0, sizeof (fileCloseInp));
00705 fileCloseInp.fileInx = L1desc[l1descInx].l3descInx;
00706 rstrcpy(fileCloseInp.in_pdmo, L1desc[l1descInx].in_pdmo, MAX_NAME_LEN);
00707 status = rsFileClose (rsComm, &fileCloseInp);
00708
00709 }
00710 return (status);
00711 }
00712
00713 int
00714 _l3Close (rsComm_t *rsComm, int rescTypeInx, int l3descInx)
00715 {
00716 fileCloseInp_t fileCloseInp;
00717 int status;
00718
00719 memset (&fileCloseInp, 0, sizeof (fileCloseInp));
00720 fileCloseInp.fileInx = l3descInx;
00721 status = rsFileClose (rsComm, &fileCloseInp);
00722
00723 return (status);
00724 }
00725
00726 int
00727 l3Stat (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, rodsStat_t **myStat)
00728 {
00729 fileStatInp_t fileStatInp;
00730 int status;
00731
00732 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00733
00734 std::string location;
00735 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00736 if( !ret.ok() ) {
00737 eirods::log( PASSMSG( "l3Stat - failed in get_loc_for_hier_string", ret ) );
00738 return -1;
00739 }
00740
00741 subFile_t subFile;
00742 memset( &subFile, 0, sizeof( subFile ) );
00743 rstrcpy( subFile.subFilePath, dataObjInfo->subPath,MAX_NAME_LEN );
00744 rstrcpy( subFile.addr.hostAddr, location.c_str(),NAME_LEN );
00745
00746 subFile.specColl = dataObjInfo->specColl;
00747 status = rsSubStructFileStat( rsComm, &subFile, myStat );
00748 } else {
00749 memset (&fileStatInp, 0, sizeof (fileStatInp));
00750 fileStatInp.fileType = static_cast<fileDriverType_t>( -1 );
00751 rstrcpy (fileStatInp.fileName, dataObjInfo->filePath,
00752 MAX_NAME_LEN);
00753 rstrcpy (fileStatInp.addr.hostAddr,
00754 dataObjInfo->rescInfo->rescLoc, NAME_LEN);
00755 rstrcpy(fileStatInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00756 rstrcpy(fileStatInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00757 status = rsFileStat (rsComm, &fileStatInp, myStat);
00758 }
00759 return (status);
00760 }
00761
00762
00763
00764
00765 int
00766 procChksumForClose (
00767 rsComm_t *rsComm,
00768 int l1descInx,
00769 char **chksumStr)
00770 {
00771 int status = 0;
00772 dataObjInfo_t *dataObjInfo = L1desc[l1descInx].dataObjInfo;
00773 int oprType = L1desc[l1descInx].oprType;
00774 int srcL1descInx;
00775 dataObjInfo_t *srcDataObjInfo;
00776
00777 *chksumStr = NULL;
00778 if (oprType == REPLICATE_DEST || oprType == PHYMV_DEST) {
00779 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00780 if (srcL1descInx <= 2) {
00781 rodsLog (LOG_NOTICE,
00782 "procChksumForClose: srcL1descInx %d out of range",
00783 srcL1descInx);
00784 return (SYS_FILE_DESC_OUT_OF_RANGE);
00785 }
00786 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00787 if (strlen (srcDataObjInfo->chksum) > 0 &&
00788 srcDataObjInfo->replStatus > 0) {
00789
00790 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00791
00792 if (status < 0) {
00793 dataObjInfo->chksum[0] = '\0';
00794 if(status == EIRODS_DIRECT_ARCHIVE_ACCESS) {
00795 *chksumStr = strdup(srcDataObjInfo->chksum);
00796 rstrcpy (dataObjInfo->chksum, *chksumStr, NAME_LEN);
00797 return 0;
00798 } else {
00799 rodsLog (LOG_NOTICE,
00800 "procChksumForClose: _dataObjChksum error for %s, status = %d",
00801 dataObjInfo->objPath, status);
00802 return status;
00803 }
00804 } else {
00805 rstrcpy (dataObjInfo->chksum, *chksumStr, NAME_LEN);
00806 if (strcmp (srcDataObjInfo->chksum, *chksumStr) != 0) {
00807
00808 free (*chksumStr);
00809 *chksumStr = NULL;
00810 rodsLog (LOG_NOTICE,
00811 "procChksumForClose: chksum mismatch for for %s",
00812 dataObjInfo->objPath);
00813 return USER_CHKSUM_MISMATCH;
00814 } else {
00815 return 0;
00816 }
00817 }
00818 }
00819 }
00820
00821
00822 if (strlen (L1desc[l1descInx].dataObjInfo->chksum) > 0)
00823 L1desc[l1descInx].chksumFlag = VERIFY_CHKSUM;
00824
00825 if (L1desc[l1descInx].chksumFlag == 0) {
00826 return 0;
00827 } else if (L1desc[l1descInx].chksumFlag == VERIFY_CHKSUM) {
00828 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00829 if (status < 0) {
00830 return (status);
00831 }
00832
00833 if (strlen (L1desc[l1descInx].chksum) > 0) {
00834
00835
00836 if (strcmp (L1desc[l1descInx].chksum, *chksumStr) != 0) {
00837 rodsLog (LOG_NOTICE,
00838 "procChksumForClose: mismatch chksum for %s.inp=%s,compute %s",
00839 dataObjInfo->objPath,
00840 L1desc[l1descInx].chksum, *chksumStr);
00841 free (*chksumStr);
00842 *chksumStr = NULL;
00843 return (USER_CHKSUM_MISMATCH);
00844 }
00845 if (strcmp (dataObjInfo->chksum, *chksumStr) == 0) {
00846
00847 free (*chksumStr);
00848 *chksumStr = NULL;
00849 }
00850 } else if (oprType == REPLICATE_DEST) {
00851 if (strlen (dataObjInfo->chksum) > 0) {
00852
00853 if (strcmp (dataObjInfo->chksum, *chksumStr) != 0) {
00854 rodsLog (LOG_NOTICE,
00855 "procChksumForClose:mismach chksum for %s.Rcat=%s,comp %s",
00856 dataObjInfo->objPath, dataObjInfo->chksum, *chksumStr);
00857 status = USER_CHKSUM_MISMATCH;
00858 } else {
00859
00860 free (*chksumStr);
00861 *chksumStr = NULL;
00862 status = 0;
00863 }
00864 }
00865 return (status);
00866 } else if (oprType == COPY_DEST) {
00867
00868 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00869 if (srcL1descInx <= 2) {
00870
00871 rodsLog (LOG_DEBUG,
00872 "procChksumForClose: invalid srcL1descInx %d for copy",
00873 srcL1descInx);
00874
00875 return 0;
00876 }
00877 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00878
00879 if (strlen (srcDataObjInfo->chksum) > 0) {
00880 if (strcmp (srcDataObjInfo->chksum, *chksumStr) != 0) {
00881 rodsLog (LOG_NOTICE,
00882 "procChksumForClose:mismach chksum for %s.Rcat=%s,comp %s",
00883 dataObjInfo->objPath, srcDataObjInfo->chksum, *chksumStr);
00884 free (*chksumStr);
00885 *chksumStr = NULL;
00886 return USER_CHKSUM_MISMATCH;
00887 }
00888 }
00889
00890 return 0;
00891 }
00892 } else {
00893 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00894 if (status < 0) {
00895 return (status);
00896 }
00897
00898 if (strlen (L1desc[l1descInx].chksum) > 0) {
00899
00900
00901 if (strcmp (dataObjInfo->chksum, L1desc[l1descInx].chksum) == 0) {
00902
00903 free (*chksumStr);
00904 *chksumStr = NULL;
00905 }
00906 return (0);
00907 } else if (oprType == COPY_DEST) {
00908
00909 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00910 if (srcL1descInx <= 2) {
00911
00912 rodsLog (LOG_DEBUG,
00913 "procChksumForClose: invalid srcL1descInx %d for copy",
00914 srcL1descInx);
00915 return (0);
00916 }
00917 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00918 if (strlen (srcDataObjInfo->chksum) == 0) {
00919 free (*chksumStr);
00920 *chksumStr = NULL;
00921 }
00922 }
00923 return (0);
00924 }
00925 return status;
00926 }
00927
00928 #ifdef COMPAT_201
00929 int
00930 rsDataObjClose201 (rsComm_t *rsComm, dataObjCloseInp_t *dataObjCloseInp)
00931 {
00932 openedDataObjInp_t openedDataObjInp;
00933 int status;
00934
00935 bzero (&openedDataObjInp, sizeof (openedDataObjInp));
00936
00937 openedDataObjInp.l1descInx = dataObjCloseInp->l1descInx;
00938 openedDataObjInp.bytesWritten = dataObjCloseInp->bytesWritten;
00939
00940 status = rsDataObjClose (rsComm, &openedDataObjInp);
00941
00942 return status;
00943 }
00944 #endif
00945