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