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