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