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( "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( 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 fileCloseInp.in_pdmo = L1desc[l1descInx].in_pdmo;
00740 status = rsFileClose (rsComm, &fileCloseInp);
00741 #if 0 // JMC - legacy resource
00742 break;
00743
00744 default:
00745 rodsLog (LOG_NOTICE,
00746 "l3Close: rescCat type %d is not recognized",
00747 RescTypeDef[rescTypeInx].rescCat);
00748 status = SYS_INVALID_RESC_TYPE;
00749 break;
00750 }
00751 #endif // JMC - legacy resource
00752 }
00753 return (status);
00754 }
00755
00756 int
00757 _l3Close (rsComm_t *rsComm, int rescTypeInx, int l3descInx)
00758 {
00759 fileCloseInp_t fileCloseInp;
00760 int status;
00761
00762 #if 0 // JMC - legacy resource
00763 switch (RescTypeDef[rescTypeInx].rescCat) {
00764 case FILE_CAT:
00765 #endif // JMC - legacy resource
00766 memset (&fileCloseInp, 0, sizeof (fileCloseInp));
00767 fileCloseInp.fileInx = l3descInx;
00768 status = rsFileClose (rsComm, &fileCloseInp);
00769 #if 0 // JMC - legacy resource
00770 break;
00771
00772 default:
00773 rodsLog (LOG_NOTICE,
00774 "_l3Close: rescCat type %d is not recognized",
00775 RescTypeDef[rescTypeInx].rescCat);
00776 status = SYS_INVALID_RESC_TYPE;
00777 break;
00778 }
00779 #endif // JMC - legacy resource
00780 return (status);
00781 }
00782
00783 int
00784 l3Stat (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, rodsStat_t **myStat)
00785 {
00786 fileStatInp_t fileStatInp;
00787 int status;
00788
00789 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00790
00791 std::string location;
00792 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00793 if( !ret.ok() ) {
00794 eirods::log( PASSMSG( "l3Stat - failed in get_loc_for_hier_string", ret ) );
00795 return -1;
00796 }
00797
00798 subFile_t subFile;
00799 memset( &subFile, 0, sizeof( subFile ) );
00800 rstrcpy( subFile.subFilePath, dataObjInfo->subPath,MAX_NAME_LEN );
00801 rstrcpy( subFile.addr.hostAddr, location.c_str(),NAME_LEN );
00802
00803 subFile.specColl = dataObjInfo->specColl;
00804 status = rsSubStructFileStat( rsComm, &subFile, myStat );
00805 } else {
00806 #if 0 // JMC - legacy resource
00807 rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00808
00809 switch (RescTypeDef[rescTypeInx].rescCat) {
00810 case FILE_CAT:
00811 #endif // JMC - legacy resource
00812 memset (&fileStatInp, 0, sizeof (fileStatInp));
00813 fileStatInp.fileType = static_cast<fileDriverType_t>( -1 );
00814 rstrcpy (fileStatInp.fileName, dataObjInfo->filePath,
00815 MAX_NAME_LEN);
00816 rstrcpy (fileStatInp.addr.hostAddr,
00817 dataObjInfo->rescInfo->rescLoc, NAME_LEN);
00818 rstrcpy(fileStatInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00819 rstrcpy(fileStatInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00820 status = rsFileStat (rsComm, &fileStatInp, myStat);
00821 #if 0 // JMC - legacy resource
00822 break;
00823
00824 default:
00825 rodsLog (LOG_NOTICE,
00826 "l3Stat: rescCat type %d is not recognized",
00827 RescTypeDef[rescTypeInx].rescCat);
00828 status = SYS_INVALID_RESC_TYPE;
00829 break;
00830 }
00831 #endif // JMC - legacy resource
00832 }
00833 return (status);
00834 }
00835
00836
00837
00838
00839 int
00840 procChksumForClose (rsComm_t *rsComm, int l1descInx, char **chksumStr)
00841 {
00842 int status = 0;
00843 dataObjInfo_t *dataObjInfo = L1desc[l1descInx].dataObjInfo;
00844 int oprType = L1desc[l1descInx].oprType;
00845 int srcL1descInx;
00846 dataObjInfo_t *srcDataObjInfo;
00847
00848 *chksumStr = NULL;
00849 if (oprType == REPLICATE_DEST || oprType == PHYMV_DEST) {
00850 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00851 if (srcL1descInx <= 2) {
00852 rodsLog (LOG_NOTICE,
00853 "procChksumForClose: srcL1descInx %d out of range",
00854 srcL1descInx);
00855 return (SYS_FILE_DESC_OUT_OF_RANGE);
00856 }
00857 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00858 if (strlen (srcDataObjInfo->chksum) > 0 &&
00859 srcDataObjInfo->replStatus > 0) {
00860
00861 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00862
00863 if (status < 0) {
00864 rodsLog (LOG_NOTICE,
00865 "procChksumForClose: _dataObjChksum error for %s, status = %d",
00866 dataObjInfo->objPath, status);
00867 return status;
00868 } else {
00869 rstrcpy (dataObjInfo->chksum, *chksumStr, NAME_LEN);
00870 if (strcmp (srcDataObjInfo->chksum, *chksumStr) != 0) {
00871 free (*chksumStr);
00872 *chksumStr = NULL;
00873 rodsLog (LOG_NOTICE,
00874 "procChksumForClose: chksum mismatch for for %s",
00875 dataObjInfo->objPath);
00876 return USER_CHKSUM_MISMATCH;
00877 } else {
00878 return 0;
00879 }
00880 }
00881 }
00882 }
00883
00884
00885 if (strlen (L1desc[l1descInx].dataObjInfo->chksum) > 0)
00886 L1desc[l1descInx].chksumFlag = VERIFY_CHKSUM;
00887
00888 if (L1desc[l1descInx].chksumFlag == 0) {
00889 return 0;
00890 } else if (L1desc[l1descInx].chksumFlag == VERIFY_CHKSUM) {
00891 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00892 if (status < 0) return (status);
00893
00894 if (strlen (L1desc[l1descInx].chksum) > 0) {
00895
00896
00897 if (strcmp (L1desc[l1descInx].chksum, *chksumStr) != 0) {
00898 rodsLog (LOG_NOTICE,
00899 "procChksumForClose: mismatch chksum for %s.inp=%s,compute %s",
00900 dataObjInfo->objPath,
00901 L1desc[l1descInx].chksum, *chksumStr);
00902 free (*chksumStr);
00903 *chksumStr = NULL;
00904 return (USER_CHKSUM_MISMATCH);
00905 }
00906 if (strcmp (dataObjInfo->chksum, *chksumStr) == 0) {
00907
00908 free (*chksumStr);
00909 *chksumStr = NULL;
00910 }
00911 } else if (oprType == REPLICATE_DEST) {
00912 if (strlen (dataObjInfo->chksum) > 0) {
00913
00914 if (strcmp (dataObjInfo->chksum, *chksumStr) != 0) {
00915 rodsLog (LOG_NOTICE,
00916 "procChksumForClose:mismach chksum for %s.Rcat=%s,comp %s",
00917 dataObjInfo->objPath, dataObjInfo->chksum, *chksumStr);
00918 status = USER_CHKSUM_MISMATCH;
00919 } else {
00920
00921 free (*chksumStr);
00922 *chksumStr = NULL;
00923 status = 0;
00924 }
00925 }
00926 return (status);
00927 } else if (oprType == COPY_DEST) {
00928
00929 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00930 if (srcL1descInx <= 2) {
00931
00932 rodsLog (LOG_DEBUG,
00933 "procChksumForClose: invalid srcL1descInx %d for copy",
00934 srcL1descInx);
00935
00936 return 0;
00937 }
00938 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00939
00940 if (strlen (srcDataObjInfo->chksum) > 0) {
00941 if (strcmp (srcDataObjInfo->chksum, *chksumStr) != 0) {
00942 rodsLog (LOG_NOTICE,
00943 "procChksumForClose:mismach chksum for %s.Rcat=%s,comp %s",
00944 dataObjInfo->objPath, srcDataObjInfo->chksum, *chksumStr);
00945 free (*chksumStr);
00946 *chksumStr = NULL;
00947 return USER_CHKSUM_MISMATCH;
00948 }
00949 }
00950
00951 return 0;
00952 }
00953 } else {
00954 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00955 if (status < 0) return (status);
00956
00957 if (strlen (L1desc[l1descInx].chksum) > 0) {
00958
00959
00960 if (strcmp (dataObjInfo->chksum, L1desc[l1descInx].chksum) == 0) {
00961
00962 free (*chksumStr);
00963 *chksumStr = NULL;
00964 }
00965 return (0);
00966 } else if (oprType == COPY_DEST) {
00967
00968 srcL1descInx = L1desc[l1descInx].srcL1descInx;
00969 if (srcL1descInx <= 2) {
00970
00971 rodsLog (LOG_DEBUG,
00972 "procChksumForClose: invalid srcL1descInx %d for copy",
00973 srcL1descInx);
00974 return (0);
00975 }
00976 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00977 if (strlen (srcDataObjInfo->chksum) == 0) {
00978 free (*chksumStr);
00979 *chksumStr = NULL;
00980 }
00981 }
00982 return (0);
00983 }
00984 return status;
00985 }
00986
00987 #ifdef COMPAT_201
00988 int
00989 rsDataObjClose201 (rsComm_t *rsComm, dataObjCloseInp_t *dataObjCloseInp)
00990 {
00991 openedDataObjInp_t openedDataObjInp;
00992 int status;
00993
00994 bzero (&openedDataObjInp, sizeof (openedDataObjInp));
00995
00996 openedDataObjInp.l1descInx = dataObjCloseInp->l1descInx;
00997 openedDataObjInp.bytesWritten = dataObjCloseInp->bytesWritten;
00998
00999 status = rsDataObjClose (rsComm, &openedDataObjInp);
01000
01001 return status;
01002 }
01003 #endif
01004