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