00001
00002
00003
00004
00005
00006 #include "dataObjOpen.h"
00007 #include "dataObjOpenAndStat.h"
00008 #include "rodsLog.h"
00009 #include "objMetaOpr.h"
00010 #include "resource.h"
00011 #include "resource.h"
00012 #include "dataObjOpr.h"
00013 #include "physPath.h"
00014 #include "dataObjCreate.h"
00015 #include "dataObjLock.h"
00016
00017 #include "fileOpen.h"
00018 #include "subStructFileOpen.h"
00019 #include "rsGlobalExtern.h"
00020 #include "rcGlobalExtern.h"
00021 #include "reGlobalsExtern.h"
00022 #include "reDefines.h"
00023 #include "reDefines.h"
00024 #include "getRemoteZoneResc.h"
00025 #include "regReplica.h"
00026 #include "regDataObj.h"
00027 #include "dataObjClose.h"
00028 #include "dataObjRepl.h"
00029
00030 int
00031 rsDataObjOpen (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00032 {
00033 int status, l1descInx;
00034 int remoteFlag;
00035 rodsServerHost_t *rodsServerHost;
00036
00037 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
00038 REMOTE_OPEN);
00039
00040 if (remoteFlag < 0) {
00041 return (remoteFlag);
00042 } else if (remoteFlag == REMOTE_HOST) {
00043 openStat_t *openStat = NULL;
00044 status = rcDataObjOpenAndStat (rodsServerHost->conn, dataObjInp,
00045 &openStat);
00046 if (status < 0) return status;
00047 l1descInx = allocAndSetL1descForZoneOpr (status, dataObjInp,
00048 rodsServerHost, openStat);
00049 if (openStat != NULL) free (openStat);
00050 return (l1descInx);
00051 } else {
00052 l1descInx = _rsDataObjOpen (rsComm, dataObjInp);
00053 }
00054
00055 return (l1descInx);
00056 }
00057
00058
00059
00060
00061
00062 int
00063 _rsDataObjOpen (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00064 {
00065 int status;
00066 dataObjInfo_t *dataObjInfoHead = NULL;
00067 dataObjInfo_t *otherDataObjInfo = NULL;
00068 dataObjInfo_t *nextDataObjInfo = NULL;
00069 dataObjInfo_t *tmpDataObjInfo;
00070 dataObjInfo_t *compDataObjInfo = NULL;
00071 dataObjInfo_t *cacheDataObjInfo = NULL;
00072 rescInfo_t *compRescInfo = NULL;
00073 #if 0 // JMC - backport 4590
00074 rescGrpInfo_t *myRescGrpInfo = NULL;
00075 #endif
00076 int l1descInx;
00077 int writeFlag;
00078 int phyOpenFlag = DO_PHYOPEN;
00079 char *lockType = NULL;
00080 int lockFd = -1;
00081
00082 if (getValByKey (&dataObjInp->condInput, NO_OPEN_FLAG_KW) != NULL) {
00083 phyOpenFlag = DO_NOT_PHYOPEN;
00084 } else if (getValByKey (&dataObjInp->condInput, PHYOPEN_BY_SIZE_KW)
00085 != NULL) {
00086 phyOpenFlag = PHYOPEN_BY_SIZE;
00087 }
00088
00089
00090 lockType = getValByKey (&dataObjInp->condInput, LOCK_TYPE_KW);
00091 if (lockType != NULL) {
00092 lockFd = rsDataObjLock (rsComm, dataObjInp);
00093 if (lockFd > 0) {
00094
00095 rmKeyVal (&dataObjInp->condInput, LOCK_TYPE_KW);
00096 } else {
00097 rodsLogError (LOG_ERROR, lockFd,
00098 "_rsDataObjOpen: rsDataObjLock error for %s. lockType = %s",
00099 dataObjInp->objPath, lockType);
00100 return lockFd;
00101 }
00102 }
00103
00104
00105
00106 status = getDataObjInfoIncSpecColl (rsComm, dataObjInp, &dataObjInfoHead);
00107
00108 writeFlag = getWriteFlag (dataObjInp->openFlags);
00109
00110 if (status < 0) {
00111 if (dataObjInp->openFlags & O_CREAT && writeFlag > 0) {
00112 l1descInx = rsDataObjCreate (rsComm, dataObjInp);
00113 status = l1descInx;
00114 }
00115
00116
00117 if (lockFd >= 0) {
00118 if (status > 0) {
00119 L1desc[l1descInx].lockFd = lockFd;
00120 } else {
00121 rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00122 }
00123 }
00124 return (status);
00125
00126 } else {
00127
00128 status = sortObjInfoForOpen (rsComm, &dataObjInfoHead,
00129 &dataObjInp->condInput, writeFlag);
00130 if (status < 0) {
00131 if (lockFd > 0) rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00132 return status;
00133 }
00134
00135 status = applyPreprocRuleForOpen (rsComm, dataObjInp, &dataObjInfoHead);
00136 if (status < 0) {
00137 if (lockFd > 0) rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00138 return status;
00139 }
00140 }
00141
00142 if (getStructFileType (dataObjInfoHead->specColl) >= 0) {
00143
00144 } else if (writeFlag > 0) {
00145
00146
00147 status = procDataObjOpenForWrite (rsComm, dataObjInp, &dataObjInfoHead, &cacheDataObjInfo, &compDataObjInfo, &compRescInfo);
00148 } else {
00149 status = procDataObjOpenForRead (rsComm, dataObjInp, &dataObjInfoHead,
00150 &cacheDataObjInfo, &compDataObjInfo, &compRescInfo);
00151 }
00152 if (status < 0) {
00153 if (lockFd > 0) rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00154 freeAllDataObjInfo (dataObjInfoHead);
00155 return status;
00156 }
00157 #if 0
00158
00159
00160 status = requeDataObjInfoByDestResc (&dataObjInfoHead, &dataObjInp->condInput, writeFlag, 1);
00161
00162
00163 if (status < 0 &&getValByKey (&dataObjInp->condInput, DEST_RESC_NAME_KW) != NULL) {
00164
00165 status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
00166 if (status < 0)
00167 return status;
00168 if (getRescClass (myRescGrpInfo->rescInfo) == COMPOUND_CL) {
00169
00170
00171
00172 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp,dataObjInfoHead, NULL, myRescGrpInfo, NULL, &cacheDataObjInfo);
00173
00174 if (status < 0) {
00175 rodsLog (LOG_ERROR,"_rsDataObjOpen: getCacheDataInfo of %s failed, stat=%d",dataObjInfoHead->objPath, status);
00176 freeAllDataObjInfo (dataObjInfoHead);
00177 freeAllRescGrpInfo (myRescGrpInfo);
00178 return status;
00179 } else {
00180 compRescInfo = myRescGrpInfo->rescInfo;
00181 }
00182 } else {
00183 status = createEmptyRepl (rsComm, dataObjInp, &dataObjInfoHead);
00184 if (status < 0) {
00185 rodsLog (LOG_ERROR,
00186 "_rsDataObjOpen: createEmptyRepl of %s failed, stat=%d",
00187 dataObjInfoHead->objPath, status);
00188 freeAllDataObjInfo (dataObjInfoHead);
00189 freeAllRescGrpInfo (myRescGrpInfo);
00190 return status;
00191 }
00192 }
00193
00194 } else if (getRescClass (dataObjInfoHead->rescInfo) == COMPOUND_CL) {
00195
00196
00197 compDataObjInfo = dataObjInfoHead;
00198 status = stageAndRequeDataToCache (rsComm, &dataObjInfoHead);
00199 if (status < 0 && status != SYS_COPY_ALREADY_IN_RESC) {
00200 rodsLog (LOG_ERROR,"_rsDataObjOpen:stageAndRequeDataToCache %s failed stat=%d",dataObjInfoHead->objPath, status);
00201 freeAllDataObjInfo (dataObjInfoHead);
00202 return status;
00203 }
00204 cacheDataObjInfo = dataObjInfoHead;
00205
00206
00207 } else if ( getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL &&
00208 getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo) >= 0 &&
00209 strlen (myRescGrpInfo->rescGroupName) > 0) {
00210
00211 if( getRescInGrpByClass ( rsComm, myRescGrpInfo->rescGroupName,COMPOUND_CL, &compRescInfo, NULL) >= 0) {
00212 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp,dataObjInfoHead, NULL, myRescGrpInfo, NULL,&cacheDataObjInfo);
00213 if (status < 0) {
00214 rodsLog (LOG_NOTICE,
00215 "_rsDataObjOpen: getCacheDataInfo of %s failed, stat=%d",
00216 dataObjInfoHead->objPath, status);
00217 } else {
00218 if (getDataObjByClass (dataObjInfoHead, COMPOUND_CL, &compDataObjInfo) >= 0) {
00219
00220 compRescInfo = NULL;
00221 }
00222 }
00223 }
00224
00225 } else if (getRescClass (dataObjInfoHead->rescInfo) == COMPOUND_CL) {
00226
00227 status = stageAndRequeDataToCache (rsComm, &dataObjInfoHead);
00228 if (status < 0 && status != SYS_COPY_ALREADY_IN_RESC) {
00229 rodsLog (LOG_ERROR,
00230 "_rsDataObjOpen: stageAndRequeDataToCache of %s failed stat=%d",
00231 dataObjInfoHead->objPath, status);
00232 freeAllDataObjInfo (dataObjInfoHead);
00233 return status;
00234 }
00235 cacheDataObjInfo = dataObjInfoHead;
00236
00237
00238 } else if (getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL &&strlen (dataObjInfoHead->rescGroupName) > 0) {
00239 if (getRescInGrpByClass (rsComm, dataObjInfoHead->rescGroupName,COMPOUND_CL, &compRescInfo, &myRescGrpInfo) >= 0) {
00240 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp, dataObjInfoHead, NULL, myRescGrpInfo, NULL,&cacheDataObjInfo);
00241 if (status < 0) {
00242 rodsLog (LOG_NOTICE, "_rsDataObjOpen: getCacheDataInfo of %s failed, stat=%d",dataObjInfoHead->objPath, status);
00243 } else {
00244 if (getDataObjByClass (dataObjInfoHead, COMPOUND_CL, &compDataObjInfo) >= 0) {
00245
00246 compRescInfo = NULL;
00247 }
00248 }
00249 }
00250 }
00251
00252 }
00253
00254 freeAllRescGrpInfo( myRescGrpInfo);
00255 #endif // JMC - backport 4590
00256
00257 if (getRescClass (dataObjInfoHead->rescInfo) == BUNDLE_CL) {
00258 status = stageBundledData (rsComm, &dataObjInfoHead);
00259 if (status < 0) {
00260 rodsLog (LOG_ERROR,
00261 "_rsDataObjOpen: stageBundledData of %s failed stat=%d",
00262 dataObjInfoHead->objPath, status);
00263 freeAllDataObjInfo (dataObjInfoHead);
00264 if (lockFd >= 0) rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00265 return status;
00266 }
00267 }
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280 tmpDataObjInfo = dataObjInfoHead;
00281
00282 while (tmpDataObjInfo != NULL) {
00283 nextDataObjInfo = tmpDataObjInfo->next;
00284 tmpDataObjInfo->next = NULL;
00285 if (getRescClass (tmpDataObjInfo->rescInfo) == COMPOUND_CL) {
00286
00287 if (compDataObjInfo != tmpDataObjInfo) {
00288
00289 queDataObjInfo (&otherDataObjInfo, tmpDataObjInfo, 1, 1);
00290 }
00291 tmpDataObjInfo = nextDataObjInfo;
00292 continue;
00293 } else if ( writeFlag > 0 && cacheDataObjInfo != NULL &&
00294 tmpDataObjInfo != cacheDataObjInfo) {
00295
00296 queDataObjInfo (&otherDataObjInfo, tmpDataObjInfo, 1, 1);
00297 tmpDataObjInfo = nextDataObjInfo;
00298 continue;
00299 }
00300
00301 status = l1descInx = _rsDataObjOpenWithObjInfo (rsComm, dataObjInp,phyOpenFlag, tmpDataObjInfo, cacheDataObjInfo);
00302
00303 if (status >= 0) {
00304 if (compDataObjInfo != NULL) {
00305 L1desc[l1descInx].replDataObjInfo = compDataObjInfo;
00306 } else if (compRescInfo != NULL) {
00307 L1desc[l1descInx].replRescInfo = compRescInfo;
00308 }
00309
00310 queDataObjInfo (&otherDataObjInfo, nextDataObjInfo, 0, 1);
00311 L1desc[l1descInx].otherDataObjInfo = otherDataObjInfo;
00312
00313 if (writeFlag > 0) {
00314 L1desc[l1descInx].openType = OPEN_FOR_WRITE_TYPE;
00315 } else {
00316 L1desc[l1descInx].openType = OPEN_FOR_READ_TYPE;
00317 }
00318
00319
00320 if (lockFd >= 0) {
00321 if (l1descInx >= 0) {
00322 L1desc[l1descInx].lockFd = lockFd;
00323 } else {
00324 rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00325 }
00326 }
00327
00328 return (l1descInx);
00329
00330 }
00331
00332 tmpDataObjInfo = nextDataObjInfo;
00333 }
00334 freeAllDataObjInfo (otherDataObjInfo);
00335
00336 return (status);
00337 }
00338
00339
00340
00341
00342
00343
00344
00345 int
00346 _rsDataObjOpenWithObjInfo (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00347 int phyOpenFlag, dataObjInfo_t *dataObjInfo, dataObjInfo_t *cacheDataObjInfo)
00348 {
00349 int replStatus;
00350 int status;
00351 int l1descInx;
00352
00353 l1descInx = allocL1desc ();
00354
00355 if (l1descInx < 0) return l1descInx;
00356
00357 replStatus = dataObjInfo->replStatus | OPEN_EXISTING_COPY;
00358
00359
00360
00361
00362 fillL1desc (l1descInx, dataObjInp, dataObjInfo, replStatus, -1);
00363 if (dataObjInfo == cacheDataObjInfo &&
00364 getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL) {
00365 L1desc[l1descInx].purgeCacheFlag = 1;
00366 }
00367 if (phyOpenFlag == DO_NOT_PHYOPEN) {
00368
00369 status = 0;
00370 } else if (phyOpenFlag == PHYOPEN_BY_SIZE) {
00371
00372 if (getValByKey (&dataObjInp->condInput, DATA_INCLUDED_KW) != NULL
00373 && dataObjInfo->dataSize <= MAX_SZ_FOR_SINGLE_BUF) {
00374 status = 0;
00375 } else if (dataObjInfo->dataSize != UNKNOWN_FILE_SZ &&
00376 dataObjInfo->dataSize < MAX_SZ_FOR_SINGLE_BUF) {
00377 status = 0;
00378 } else {
00379 status = dataOpen (rsComm, l1descInx);
00380 }
00381 } else {
00382 status = dataOpen (rsComm, l1descInx);
00383 }
00384
00385 if (status < 0) {
00386 freeL1desc (l1descInx);
00387 return (status);
00388 } else {
00389 return (l1descInx);
00390 }
00391 }
00392
00393 int
00394 dataOpen (rsComm_t *rsComm, int l1descInx)
00395 {
00396 dataObjInfo_t *myDataObjInfo = L1desc[l1descInx].dataObjInfo;
00397 int status;
00398
00399
00400 status = l3Open (rsComm, l1descInx);
00401
00402 if (status <= 0) {
00403 rodsLog (LOG_NOTICE,
00404 "dataOpen: l3Open of %s failed, status = %d",
00405 myDataObjInfo->filePath, status);
00406 return (status);
00407 } else {
00408 L1desc[l1descInx].l3descInx = status;
00409 return (0);
00410 }
00411 }
00412
00413 int
00414 l3Open (rsComm_t *rsComm, int l1descInx)
00415 {
00416 dataObjInfo_t *dataObjInfo;
00417 int l3descInx;
00418 int mode, flags;
00419
00420 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00421
00422 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00423 subFile_t subFile;
00424 memset (&subFile, 0, sizeof (subFile));
00425 rstrcpy (subFile.subFilePath, dataObjInfo->subPath,
00426 MAX_NAME_LEN);
00427 rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
00428 NAME_LEN);
00429 subFile.specColl = dataObjInfo->specColl;
00430 subFile.mode = getFileMode (L1desc[l1descInx].dataObjInp);
00431 subFile.flags = getFileFlags (l1descInx);
00432 l3descInx = rsSubStructFileOpen (rsComm, &subFile);
00433 } else {
00434 mode = getFileMode (L1desc[l1descInx].dataObjInp);
00435 flags = getFileFlags (l1descInx);
00436 l3descInx = _l3Open (rsComm, dataObjInfo, mode, flags);
00437 }
00438 return (l3descInx);
00439 }
00440
00441 int
00442 _l3Open (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, int mode, int flags)
00443 {
00444 int rescTypeInx;
00445 int l3descInx;
00446 fileOpenInp_t fileOpenInp;
00447
00448 rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00449
00450 switch (RescTypeDef[rescTypeInx].rescCat) {
00451 case FILE_CAT:
00452 memset (&fileOpenInp, 0, sizeof (fileOpenInp));
00453 fileOpenInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
00454 rstrcpy (fileOpenInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
00455 NAME_LEN);
00456 rstrcpy (fileOpenInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00457 fileOpenInp.mode = mode;
00458 fileOpenInp.flags = flags;
00459 l3descInx = rsFileOpen (rsComm, &fileOpenInp);
00460 break;
00461 default:
00462 rodsLog (LOG_NOTICE,
00463 "l3Open: rescCat type %d is not recognized",
00464 RescTypeDef[rescTypeInx].rescCat);
00465 l3descInx = SYS_INVALID_RESC_TYPE;
00466 break;
00467 }
00468 return (l3descInx);
00469 }
00470
00471
00472
00473
00474
00475 int
00476 l3OpenByHost (rsComm_t *rsComm, int rescTypeInx, int l3descInx, int flags)
00477 {
00478 fileOpenInp_t fileOpenInp;
00479 int newL3descInx;
00480
00481 switch (RescTypeDef[rescTypeInx].rescCat) {
00482 case FILE_CAT:
00483 memset (&fileOpenInp, 0, sizeof (fileOpenInp));
00484 fileOpenInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
00485 rstrcpy (fileOpenInp.fileName, FileDesc[l3descInx].fileName,
00486 MAX_NAME_LEN);
00487 fileOpenInp.mode = FileDesc[l3descInx].mode;
00488 fileOpenInp.flags = flags;
00489 newL3descInx = rsFileOpenByHost (rsComm, &fileOpenInp,
00490 FileDesc[l3descInx].rodsServerHost);
00491 break;
00492 default:
00493 rodsLog (LOG_NOTICE,
00494 "l3OpenByHost: rescCat type %d is not recognized",
00495 RescTypeDef[rescTypeInx].rescCat);
00496 l3descInx = SYS_INVALID_RESC_TYPE;
00497 break;
00498 }
00499 return (newL3descInx);
00500 }
00501
00502 int
00503 applyPreprocRuleForOpen (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00504 dataObjInfo_t **dataObjInfoHead)
00505 {
00506 int status;
00507 ruleExecInfo_t rei;
00508
00509 initReiWithDataObjInp (&rei, rsComm, dataObjInp);
00510 rei.doi = *dataObjInfoHead;
00511
00512 status = applyRule ("acPreprocForDataObjOpen", NULL, &rei, NO_SAVE_REI);
00513
00514 if (status < 0) {
00515 if (rei.status < 0) {
00516 status = rei.status;
00517 }
00518 rodsLog (LOG_ERROR,
00519 "applyPreprocRuleForOpen:acPreprocForDataObjOpen error for %s,stat=%d",
00520 dataObjInp->objPath, status);
00521 } else {
00522 *dataObjInfoHead = rei.doi;
00523 }
00524 return (status);
00525 }
00526
00527
00528
00529
00530 int
00531 createEmptyRepl (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00532 dataObjInfo_t **dataObjInfoHead)
00533 {
00534 int status;
00535 char *rescName;
00536 rescInfo_t *rescInfo;
00537 rescGrpInfo_t *tmpRescGrpInfo;
00538 regReplica_t regReplicaInp;
00539 rescGrpInfo_t *myRescGrpInfo = NULL;
00540 keyValPair_t *condInput = &dataObjInp->condInput;
00541 dataObjInfo_t *myDataObjInfo;
00542
00543 if ((rescName = getValByKey (condInput, DEST_RESC_NAME_KW)) == NULL &&
00544 (rescName = getValByKey (condInput, BACKUP_RESC_NAME_KW)) == NULL &&
00545 (rescName = getValByKey (condInput, DEF_RESC_NAME_KW)) == NULL) {
00546 return USER_NO_RESC_INPUT_ERR;
00547 }
00548
00549 status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
00550 if (status < 0 || myRescGrpInfo == NULL ) return status;
00551
00552 myDataObjInfo = (dataObjInfo_t*)malloc (sizeof (dataObjInfo_t));
00553 *myDataObjInfo = *(*dataObjInfoHead);
00554 tmpRescGrpInfo = myRescGrpInfo;
00555 while (tmpRescGrpInfo != NULL) {
00556 rescInfo = tmpRescGrpInfo->rescInfo;
00557 myDataObjInfo->rescInfo = rescInfo;
00558 rstrcpy (myDataObjInfo->rescName, rescInfo->rescName, NAME_LEN);
00559 rstrcpy (myDataObjInfo->rescGroupName, myRescGrpInfo->rescGroupName,
00560 NAME_LEN);
00561 status = getFilePathName (rsComm, myDataObjInfo, dataObjInp);
00562 if (status < 0) {
00563 tmpRescGrpInfo = tmpRescGrpInfo->next;
00564 continue;
00565 }
00566 status = l3CreateByObjInfo (rsComm, dataObjInp, myDataObjInfo);
00567 if (status < 0) {
00568 tmpRescGrpInfo = tmpRescGrpInfo->next;
00569 continue;
00570 }
00571
00572 _l3Close (rsComm, rescInfo->rescTypeInx, status);
00573
00574
00575 memset (®ReplicaInp, 0, sizeof (regReplicaInp));
00576 regReplicaInp.srcDataObjInfo = *dataObjInfoHead;
00577 regReplicaInp.destDataObjInfo = myDataObjInfo;
00578 if (getValByKey (&dataObjInp->condInput, IRODS_ADMIN_KW) != NULL) {
00579 addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, "");
00580 }
00581 status = rsRegReplica (rsComm, ®ReplicaInp);
00582 clearKeyVal (®ReplicaInp.condInput);
00583
00584 break;
00585 }
00586
00587 freeAllRescGrpInfo (myRescGrpInfo);
00588
00589 if (status < 0) {
00590 free (myDataObjInfo);
00591 } else {
00592
00593 myDataObjInfo->next = *dataObjInfoHead;
00594 *dataObjInfoHead = myDataObjInfo;
00595 }
00596 return status;
00597 }
00598
00599
00600
00601 int
00602 procDataObjOpenForWrite (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00603 dataObjInfo_t **dataObjInfoHead, dataObjInfo_t **cacheDataObjInfo,
00604 dataObjInfo_t **compDataObjInfo, rescInfo_t **compRescInfo)
00605 {
00606 int status = 0;
00607 rescGrpInfo_t *myRescGrpInfo = NULL;
00608
00609
00610 status = requeDataObjInfoByDestResc (dataObjInfoHead,
00611 &dataObjInp->condInput, 1, 1);
00612
00613 if (status < 0 &&
00614 getValByKey (&dataObjInp->condInput, DEST_RESC_NAME_KW) != NULL) {
00615
00616 status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
00617 if (status < 0) return status;
00618 if (getRescClass (myRescGrpInfo->rescInfo) == COMPOUND_CL) {
00619
00620
00621 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp,
00622 *dataObjInfoHead, NULL, myRescGrpInfo, NULL,
00623 cacheDataObjInfo);
00624 if (status < 0) {
00625 rodsLogError (LOG_ERROR, status,
00626 "procDataObjForOpenWrite: getCacheDataInfo of %s failed",
00627 (*dataObjInfoHead)->objPath);
00628 freeAllRescGrpInfo (myRescGrpInfo);
00629 return status;
00630 } else {
00631
00632 *compRescInfo = myRescGrpInfo->rescInfo;
00633 }
00634 } else {
00635
00636 status = createEmptyRepl (rsComm, dataObjInp, dataObjInfoHead);
00637 if (status < 0) {
00638 rodsLogError (LOG_ERROR, status,
00639 "procDataObjForOpenWrite: createEmptyRepl of %s failed",
00640 (*dataObjInfoHead)->objPath);
00641 freeAllRescGrpInfo (myRescGrpInfo);
00642 return status;
00643 }
00644 }
00645 } else {
00646 status = procDataObjOpenForExistObj (rsComm, dataObjInp,
00647 dataObjInfoHead, cacheDataObjInfo, compDataObjInfo, compRescInfo);
00648 #if 0
00649 if (getRescClass ((*dataObjInfoHead)->rescInfo) == COMPOUND_CL) {
00650
00651
00652 *compDataObjInfo = *dataObjInfoHead;
00653 status = stageAndRequeDataToCache (rsComm, dataObjInfoHead);
00654 if (status < 0 && status != SYS_COPY_ALREADY_IN_RESC) {
00655 rodsLogError (LOG_ERROR, status,
00656 "procDataObjForOpenWrite:stageAndRequeDataToCache %s failed",
00657 (*dataObjInfoHead)->objPath);
00658 return status;
00659 }
00660 *cacheDataObjInfo = *dataObjInfoHead;
00661 } else if (getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL
00662 && getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo) >= 0 &&
00663 strlen (myRescGrpInfo->rescGroupName) > 0) {
00664
00665
00666 if (getRescInGrpByClass (rsComm, myRescGrpInfo->rescGroupName,
00667 COMPOUND_CL, compRescInfo, NULL) >= 0) {
00668
00669 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp,
00670 *dataObjInfoHead, NULL, myRescGrpInfo, NULL, cacheDataObjInfo);
00671 if (status < 0) {
00672 rodsLogError (LOG_NOTICE, status,
00673 "procDataObjForOpenWrite: getCacheDataInfo of %s failed",
00674 (*dataObjInfoHead)->objPath);
00675 } else {
00676 if (getDataObjByClass (*dataObjInfoHead, COMPOUND_CL,
00677 compDataObjInfo) >= 0) {
00678
00679 *compRescInfo = NULL;
00680 }
00681 }
00682 }
00683 }
00684 #endif
00685 }
00686 if (*compDataObjInfo != NULL) {
00687 dequeDataObjInfo (dataObjInfoHead, *compDataObjInfo);
00688 }
00689 freeAllRescGrpInfo (myRescGrpInfo);
00690 return status;
00691 }
00692
00693
00694
00695
00696
00697
00698 int
00699 procDataObjOpenForExistObj (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00700 dataObjInfo_t **dataObjInfoHead, dataObjInfo_t **cacheDataObjInfo,
00701 dataObjInfo_t **compDataObjInfo, rescInfo_t **compRescInfo)
00702 {
00703 int status = 0;
00704 rescGrpInfo_t *myRescGrpInfo = NULL;
00705
00706 if (getRescClass ((*dataObjInfoHead)->rescInfo) == COMPOUND_CL) {
00707
00708
00709 *compDataObjInfo = *dataObjInfoHead;
00710 status = stageAndRequeDataToCache (rsComm, dataObjInfoHead);
00711 if (status < 0 && status != SYS_COPY_ALREADY_IN_RESC) {
00712 rodsLogError (LOG_ERROR, status,
00713 "procDataObjOpenForExistObj:stageAndRequeDataToCache of %s failed",
00714 (*dataObjInfoHead)->objPath);
00715 return status;
00716 }
00717 *cacheDataObjInfo = *dataObjInfoHead;
00718 } else if (getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL &&
00719 strlen ((*dataObjInfoHead)->rescGroupName) > 0) {
00720
00721
00722 if (getRescInGrpByClass (rsComm, (*dataObjInfoHead)->rescGroupName,
00723 COMPOUND_CL, compRescInfo, &myRescGrpInfo) >= 0) {
00724
00725 status = getCacheDataInfoOfCompResc (rsComm, dataObjInp,
00726 *dataObjInfoHead, NULL, myRescGrpInfo, NULL,
00727 cacheDataObjInfo);
00728 if (status < 0) {
00729 rodsLogError (LOG_NOTICE, status,
00730 "procDataObjOpenForExistObj: getCacheDataInfo of %s failed",
00731 (*dataObjInfoHead)->objPath);
00732 } else {
00733 if (getDataObjByClass (*dataObjInfoHead, COMPOUND_CL,
00734 compDataObjInfo) >= 0) {
00735
00736 *compRescInfo = NULL;
00737 }
00738 }
00739 }
00740 }
00741 freeAllRescGrpInfo (myRescGrpInfo);
00742 return status;
00743 }
00744
00745 int
00746 procDataObjOpenForRead (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00747 dataObjInfo_t **dataObjInfoHead, dataObjInfo_t **cacheDataObjInfo,
00748 dataObjInfo_t **compDataObjInfo, rescInfo_t **compRescInfo)
00749 {
00750 int status = 0;
00751
00752 status = procDataObjOpenForExistObj (rsComm, dataObjInp, dataObjInfoHead,
00753 cacheDataObjInfo, compDataObjInfo, compRescInfo);
00754
00755 if (*compDataObjInfo != NULL) {
00756 dequeDataObjInfo (dataObjInfoHead, *compDataObjInfo);
00757 freeDataObjInfo (*compDataObjInfo);
00758 *compDataObjInfo = NULL;
00759 }
00760 *compRescInfo = NULL;
00761 return status;
00762 }
00763
00764