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