00001
00002
00003
00004
00005
00006
00007
00008 #include "dataObjCreate.h"
00009 #include "dataObjCreateAndStat.h"
00010 #include "dataObjOpen.h"
00011 #include "fileCreate.h"
00012 #include "subStructFileCreate.h"
00013 #include "rodsLog.h"
00014 #include "objMetaOpr.h"
00015 #include "resource.h"
00016 #include "specColl.h"
00017 #include "dataObjOpr.h"
00018 #include "physPath.h"
00019 #include "dataObjUnlink.h"
00020 #include "dataObjLock.h"
00021 #include "regDataObj.h"
00022 #include "rcGlobalExtern.h"
00023 #include "reGlobalsExtern.h"
00024 #include "reDefines.h"
00025 #include "getRemoteZoneResc.h"
00026 #include "getRescQuota.h"
00027 #include "icatHighLevelRoutines.h"
00028
00029 #include "eirods_hierarchy_parser.h"
00030
00031
00032
00033
00034 #include "eirods_resource_backport.h"
00035 #include "eirods_resource_redirect.h"
00036 #include "eirods_hierarchy_parser.h"
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047 int
00048 rsDataObjCreate (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00049 {
00050 int l1descInx;
00051 int status;
00052 rodsObjStat_t *rodsObjStatOut = NULL;
00053 int remoteFlag;
00054 rodsServerHost_t *rodsServerHost;
00055 specCollCache_t *specCollCache = NULL;
00056 char *lockType = NULL;
00057 int lockFd = -1;
00058
00059 resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
00060 &dataObjInp->condInput);
00061 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
00062 REMOTE_CREATE);
00063 if (remoteFlag < 0) {
00064 return (remoteFlag);
00065 } else if (remoteFlag == REMOTE_HOST) {
00066 openStat_t *openStat = NULL;
00067 addKeyVal (&dataObjInp->condInput, CROSS_ZONE_CREATE_KW, "");
00068 status = rcDataObjCreateAndStat( rodsServerHost->conn, dataObjInp, &openStat );
00069
00070
00071 rmKeyVal( &dataObjInp->condInput, CROSS_ZONE_CREATE_KW );
00072 if (status < 0)
00073 return status;
00074 l1descInx = allocAndSetL1descForZoneOpr( status, dataObjInp,rodsServerHost, openStat );
00075
00076 if (openStat != NULL)
00077 free (openStat);
00078 return (l1descInx);
00079 }
00080
00081
00082
00083
00084
00085 char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
00086 if( NULL == resc_hier ) {
00087 std::string hier;
00088 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_CREATE_OPERATION, rsComm,
00089 dataObjInp, hier );
00090 if( !ret.ok() ) {
00091 std::stringstream msg;
00092 msg << "failed in eirods::resolve_resource_hierarchy for [";
00093 msg << dataObjInp->objPath << "]";
00094 eirods::log( PASSMSG( msg.str(), ret ) );
00095 return ret.code();
00096 }
00097
00098
00099
00100
00101 addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00102
00103 }
00104
00105
00106
00107 lockType = getValByKey( &dataObjInp->condInput, LOCK_TYPE_KW );
00108 if (lockType != NULL) {
00109 lockFd = rsDataObjLock (rsComm, dataObjInp);
00110 if (lockFd >= 0) {
00111
00112 rmKeyVal (&dataObjInp->condInput, LOCK_TYPE_KW);
00113 } else {
00114 rodsLogError (LOG_ERROR, lockFd,
00115 "rsDataObjCreate: rsDataObjLock error for %s. lockType = %s",
00116 dataObjInp->objPath, lockType);
00117 return lockFd;
00118 }
00119 }
00120
00121
00122
00123 addKeyVal (&dataObjInp->condInput, SEL_OBJ_TYPE_KW, "dataObj");
00124
00125 status = rsObjStat (rsComm, dataObjInp, &rodsObjStatOut);
00126
00127 if(rodsObjStatOut != NULL && rodsObjStatOut->objType == COLL_OBJ_T) {
00128 if (lockFd >= 0) rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00129 return (USER_INPUT_PATH_ERR);
00130 }
00131
00132 if( rodsObjStatOut != NULL &&
00133 rodsObjStatOut->specColl != NULL &&
00134 rodsObjStatOut->specColl->collClass == LINKED_COLL ) {
00135
00136 if( lockFd >= 0 ) {
00137 rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00138 }
00139
00140 return SYS_COLL_LINK_PATH_ERR;
00141 }
00142
00143
00144 if ( rodsObjStatOut == NULL ||
00145 ( rodsObjStatOut->objType == UNKNOWN_OBJ_T &&
00146 rodsObjStatOut->specColl == NULL ) ) {
00147
00148
00149
00150
00151 l1descInx = _rsDataObjCreate (rsComm, dataObjInp);
00152
00153 } else if( rodsObjStatOut->specColl != NULL &&
00154 rodsObjStatOut->objType == UNKNOWN_OBJ_T) {
00155
00156
00157
00158 l1descInx = specCollSubCreate (rsComm, dataObjInp);
00159 } else {
00160
00161
00162 if (getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) {
00163 dataObjInp->openFlags |= O_TRUNC | O_RDWR;
00164
00165
00166
00167 std::string hier;
00168 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_OPEN_OPERATION,
00169 rsComm, dataObjInp, hier );
00170 if( !ret.ok() ) {
00171 std::stringstream msg;
00172 msg << __FUNCTION__;
00173 msg << " :: failed in eirods::resolve_resource_hierarchy for [";
00174 msg << dataObjInp->objPath << "]";
00175 eirods::log( PASSMSG( msg.str(), ret ) );
00176 return ret.code();
00177 }
00178
00179
00180
00181
00182 addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00183 std::string top_resc;
00184 eirods::hierarchy_parser parser;
00185 parser.set_string(hier);
00186 parser.first_resc(top_resc);
00187 addKeyVal( &dataObjInp->condInput, DEST_RESC_NAME_KW, top_resc.c_str());
00188 l1descInx = _rsDataObjOpen (rsComm, dataObjInp);
00189
00190 } else {
00191 l1descInx = OVERWRITE_WITHOUT_FORCE_FLAG;
00192 }
00193 }
00194
00195 if( rodsObjStatOut != NULL ) {
00196 freeRodsObjStat (rodsObjStatOut);
00197 }
00198
00199
00200
00201 if (lockFd >= 0) {
00202 if (l1descInx >= 0) {
00203 L1desc[l1descInx].lockFd = lockFd;
00204 } else {
00205 rsDataObjUnlock (rsComm, dataObjInp, lockFd);
00206 }
00207 }
00208
00209
00210 return (l1descInx);
00211 }
00212
00213 int
00214 _rsDataObjCreate (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00215 {
00216
00217 int status;
00218 rescGrpInfo_t* myRescGrpInfo = 0;
00219 int l1descInx;
00220
00221
00222 status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo );
00223 if( status < 0 ) {
00224 rodsLog( LOG_ERROR, "_rsDataObjCreate : failed in call to getRescGrpForCreate. status = %d", status );
00225 return status;
00226 }
00227
00228 #if 1 // JMC - legacy resource
00229 status = l1descInx = _rsDataObjCreateWithRescInfo( rsComm, dataObjInp, myRescGrpInfo->rescInfo, myRescGrpInfo->rescGroupName );
00230 #else // JMC - legacy resource
00231 rescCnt = getRescCnt (myRescGrpInfo);
00232
00233 copiesNeeded = getCopiesFromCond (&dataObjInp->condInput);
00234
00235
00236 tmpRescGrpInfo = myRescGrpInfo;
00237 while (tmpRescGrpInfo != NULL) {
00238 tmpRescInfo = tmpRescGrpInfo->rescInfo;
00239 status = l1descInx = _rsDataObjCreateWithRescInfo( rsComm, dataObjInp,
00240 tmpRescInfo, myRescGrpInfo->rescGroupName );
00241
00242 if (status < 0) {
00243 failedCount++;
00244 if (copiesNeeded == ALL_COPIES || (rescCnt - failedCount < copiesNeeded)) {
00245
00246 freeAllRescGrpInfo (myRescGrpInfo);
00247 return (status);
00248 }
00249 } else {
00250
00251 if (copiesNeeded == ALL_COPIES || copiesNeeded > 1) {
00252 if (tmpRescGrpInfo->next != NULL) {
00253 L1desc[l1descInx].moreRescGrpInfo = tmpRescGrpInfo->next;
00254
00255 L1desc[l1descInx].copiesNeeded = copiesNeeded;
00256 }
00257 }
00258 L1desc[l1descInx].openType = CREATE_TYPE;
00259 freeAllRescGrpInfo (myRescGrpInfo);
00260
00261
00262 return (l1descInx);
00263 }
00264 tmpRescGrpInfo = tmpRescGrpInfo->next;
00265 }
00266
00267 #endif // JMC - remove resource.c
00268
00269
00270
00271
00272
00273
00274
00275 if( status >= 0 ) {
00276 return (status);
00277 } else {
00278 rodsLog (LOG_NOTICE,
00279 "rsDataObjCreate: Internal error");
00280 return (SYS_INTERNAL_NULL_INPUT_ERR);
00281 }
00282 }
00283
00284 int
00285 specCollSubCreate (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00286 {
00287 int status;
00288 int l1descInx;
00289 dataObjInfo_t *dataObjInfo = NULL;
00290
00291 status = resolvePathInSpecColl (rsComm, dataObjInp->objPath,
00292 WRITE_COLL_PERM, 0, &dataObjInfo);
00293 if( dataObjInfo == NULL ) {
00294 rodsLog( LOG_ERROR, "specCollSubCreate :: dataObjInp is null" );
00295 return status;
00296 }
00297 if (status >= 0) {
00298 rodsLog (LOG_ERROR,
00299 "specCollSubCreate: phyPath %s already exist",
00300 dataObjInfo->filePath);
00301 freeDataObjInfo (dataObjInfo);
00302 return (SYS_COPY_ALREADY_IN_RESC);
00303 } else if (status != SYS_SPEC_COLL_OBJ_NOT_EXIST) {
00304 return (status);
00305 }
00306
00307 l1descInx = allocL1desc ();
00308
00309 if (l1descInx < 0) return l1descInx;
00310
00311 dataObjInfo->replStatus = NEWLY_CREATED_COPY;
00312 fillL1desc (l1descInx, dataObjInp, dataObjInfo, NEWLY_CREATED_COPY,
00313 dataObjInp->dataSize);
00314
00315 if (getValByKey (&dataObjInp->condInput, NO_OPEN_FLAG_KW) == NULL) {
00316 status = dataCreate (rsComm, l1descInx);
00317 if (status < 0) {
00318 freeL1desc (l1descInx);
00319 return (status);
00320 }
00321 }
00322
00323 return l1descInx;
00324 }
00325
00326
00327
00328
00329
00330
00331
00332 int
00333 _rsDataObjCreateWithRescInfo (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00334 rescInfo_t *rescInfo, char *rescGroupName)
00335 {
00336 dataObjInfo_t *dataObjInfo;
00337 int l1descInx;
00338 int status;
00339
00340 l1descInx = allocL1desc ();
00341 if (l1descInx < 0) return l1descInx;
00342
00343 dataObjInfo = (dataObjInfo_t*)malloc(sizeof (dataObjInfo_t));
00344 initDataObjInfoWithInp (dataObjInfo, dataObjInp);
00345
00346
00347
00348 #if 0 // JMC - remove legacy resources
00349 if (getRescClass (rescInfo) == COMPOUND_CL) {
00350 rescInfo_t *cacheResc = NULL;
00351 char myRescGroupName[NAME_LEN];
00352
00353 rstrcpy (myRescGroupName, rescGroupName, NAME_LEN);
00354 status = getCacheRescInGrp (rsComm, myRescGroupName, rescInfo, &cacheResc);
00355
00356 if (status < 0 || cacheResc == NULL ) {
00357 rodsLog (LOG_ERROR,
00358 "DataObjCreateWithResInfo:getCacheRescInGrp %s err for %s stat=%d",
00359 rescGroupName, dataObjInfo->objPath, status);
00360 free (dataObjInfo);
00361 freeL1desc (l1descInx);
00362 return status;
00363 }
00364
00365 L1desc[l1descInx].replRescInfo = rescInfo;
00366 dataObjInfo->rescInfo = cacheResc;
00367 rstrcpy (dataObjInfo->rescName, cacheResc->rescName, NAME_LEN);
00368 rstrcpy (dataObjInfo->rescGroupName, myRescGroupName, NAME_LEN);
00369 if (getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL) {
00370 L1desc[l1descInx].purgeCacheFlag = 1;
00371 }
00372
00373 } else {
00374 #endif
00375 dataObjInfo->rescInfo = new rescInfo_t;
00376 memcpy( dataObjInfo->rescInfo, rescInfo, sizeof( rescInfo_t ) );
00377 rstrcpy (dataObjInfo->rescName, rescInfo->rescName, NAME_LEN);
00378 rstrcpy (dataObjInfo->rescGroupName, rescGroupName, NAME_LEN);
00379
00380 char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
00381 if( resc_hier ) {
00382 rstrcpy( dataObjInfo->rescHier, resc_hier, MAX_NAME_LEN);
00383
00384 } else {
00385 rstrcpy(dataObjInfo->rescHier, rescInfo->rescName, MAX_NAME_LEN);
00386
00387 }
00388
00389 #if 0 // JMC - remove legacy resources
00390
00391
00392 if( getValByKey (&dataObjInp->condInput, PURGE_CACHE_KW) != NULL &&
00393 getRescClass (rescInfo) == CACHE_CL) {
00394 rescInfo_t *compResc = NULL;
00395 if( getRescInGrpByClass (rsComm, rescGroupName, COMPOUND_CL,
00396 &compResc, NULL) >= 0) {
00397 L1desc[l1descInx].replRescInfo = compResc;
00398 L1desc[l1descInx].purgeCacheFlag = 1;
00399 }
00400 }
00401 }
00402 #endif // JMC - remove legacy resources
00403
00404 dataObjInfo->replStatus = NEWLY_CREATED_COPY;
00405 fillL1desc( l1descInx, dataObjInp, dataObjInfo, NEWLY_CREATED_COPY,
00406 dataObjInp->dataSize );
00407
00408 status = getFilePathName (rsComm, dataObjInfo, L1desc[l1descInx].dataObjInp);
00409
00410 if (status < 0) {
00411 freeL1desc (l1descInx);
00412 return (status);
00413 }
00414
00415
00416
00417
00418 if (getValByKey (&dataObjInp->condInput, NO_OPEN_FLAG_KW) != NULL) {
00419
00420
00421 status = 0;
00422 } else {
00423
00424 status = dataObjCreateAndReg( rsComm, l1descInx );
00425 }
00426
00427 if (status < 0) {
00428 freeL1desc (l1descInx);
00429 return (status);
00430 } else {
00431 return (l1descInx);
00432 }
00433 }
00434
00435
00436
00437
00438
00439 int
00440 dataObjCreateAndReg (rsComm_t *rsComm, int l1descInx)
00441 {
00442
00443 dataObjInfo_t *myDataObjInfo = L1desc[l1descInx].dataObjInfo;
00444 int status;
00445
00446 status = dataCreate (rsComm, l1descInx);
00447
00448 if (status < 0) {
00449 return (status);
00450 }
00451
00452
00453 status = svrRegDataObj (rsComm, myDataObjInfo);
00454 if (status < 0) {
00455 l3Unlink (rsComm, myDataObjInfo);
00456 rodsLog (LOG_NOTICE,
00457 "dataObjCreateAndReg: rsRegDataObj for %s failed, status = %d",
00458 myDataObjInfo->objPath, status);
00459 return (status);
00460 } else {
00461 myDataObjInfo->replNum = status;
00462 return (0);
00463 }
00464 }
00465
00466
00467
00468
00469
00470 int
00471 dataCreate (rsComm_t *rsComm, int l1descInx)
00472 {
00473 dataObjInfo_t *myDataObjInfo = L1desc[l1descInx].dataObjInfo;
00474 int status;
00475
00476
00477
00478 status = l3Create (rsComm, l1descInx);
00479
00480 if (status <= 0) {
00481 rodsLog (LOG_NOTICE,
00482 "dataCreate: l3Create of %s failed, status = %d",
00483 myDataObjInfo->filePath, status);
00484 return (status);
00485 } else {
00486 L1desc[l1descInx].l3descInx = status;
00487 }
00488
00489 return (0);
00490 }
00491
00492 int
00493 l3Create (rsComm_t *rsComm, int l1descInx)
00494 {
00495 dataObjInfo_t *dataObjInfo;
00496 int l3descInx;
00497
00498 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00499
00500
00501
00502 std::string location;
00503 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00504 if( !ret.ok() ) {
00505 eirods::log( PASSMSG( "l3Create - failed in get_loc_for_hier_String", ret ) );
00506 return -1;
00507 }
00508
00509
00510 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00511 subFile_t subFile;
00512 memset (&subFile, 0, sizeof (subFile));
00513 rstrcpy (subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
00514 rstrcpy (subFile.addr.hostAddr, location.c_str(), NAME_LEN );
00515
00516 subFile.specColl = dataObjInfo->specColl;
00517 subFile.mode = getFileMode (L1desc[l1descInx].dataObjInp);
00518 l3descInx = rsSubStructFileCreate (rsComm, &subFile);
00519 } else {
00520
00521 l3descInx = l3CreateByObjInfo (rsComm, L1desc[l1descInx].dataObjInp,
00522 L1desc[l1descInx].dataObjInfo);
00523 }
00524
00525 return (l3descInx);
00526 }
00527
00528 int
00529 l3CreateByObjInfo (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00530 dataObjInfo_t *dataObjInfo)
00531 {
00532 int l3descInx;
00533
00534 #if 0 // JMC legacy resource
00535
00536
00537
00538
00539
00540 #endif // JMC legacy resource
00541 int retryCnt = 0;
00542 int chkType = 0;
00543
00544
00545
00546 std::string location;
00547 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00548 if( !ret.ok() ) {
00549 eirods::log( PASSMSG( "l3CreateByObjInfo - failed in get_loc_for_hier_String", ret ) );
00550 return -1;
00551 }
00552
00553
00554 fileCreateInp_t fileCreateInp;
00555 memset (&fileCreateInp, 0, sizeof (fileCreateInp));
00556 rstrcpy( fileCreateInp.resc_name_, location.c_str(), MAX_NAME_LEN );
00557 rstrcpy( fileCreateInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN );
00558 rstrcpy( fileCreateInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN );
00559 fileCreateInp.fileType = static_cast< fileDriverType_t >( -1 );
00560 rstrcpy( fileCreateInp.addr.hostAddr, location.c_str(), NAME_LEN );
00561
00562 rstrcpy (fileCreateInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00563 fileCreateInp.mode = getFileMode (dataObjInp);
00564
00565
00566 chkType = getchkPathPerm (rsComm, dataObjInp, dataObjInfo);
00567 if (chkType == DISALLOW_PATH_REG) {
00568 return PATH_REG_NOT_ALLOWED;
00569 } else if (chkType == NO_CHK_PATH_PERM) {
00570 fileCreateInp.otherFlags |= NO_CHK_PERM_FLAG;
00571 }
00572 fileCreateInp.in_pdmo = dataObjInfo->in_pdmo;
00573
00574
00575 std::string prev_resc_hier = fileCreateInp.resc_hier_;
00576 l3descInx = rsFileCreate (rsComm, &fileCreateInp);
00577
00578
00579 rstrcpy(dataObjInfo->rescHier, fileCreateInp.resc_hier_, MAX_NAME_LEN);
00580 rstrcpy(dataObjInfo->filePath, fileCreateInp.fileName, MAX_NAME_LEN);
00581
00582
00583 while( l3descInx <= 2 && retryCnt < 100 &&
00584 getErrno (l3descInx) == EEXIST ) {
00585 if (resolveDupFilePath (rsComm, dataObjInfo, dataObjInp) < 0) {
00586 break;
00587 }
00588 rstrcpy (fileCreateInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00589 l3descInx = rsFileCreate (rsComm, &fileCreateInp);
00590
00591 rstrcpy(dataObjInfo->rescHier, fileCreateInp.resc_hier_, MAX_NAME_LEN);
00592 rstrcpy(dataObjInfo->filePath, fileCreateInp.fileName, MAX_NAME_LEN);
00593 retryCnt ++;
00594 }
00595 #if 0 // JMC legacy resource
00596 break;
00597
00598 default:
00599 rodsLog (LOG_NOTICE,
00600 "l3Create: rescCat type %d is not recognized",
00601 RescTypeDef[rescTypeInx].rescCat);
00602 l3descInx = SYS_INVALID_RESC_TYPE;
00603 break;
00604
00605 #endif // JMC legacy resource
00606 return (l3descInx);
00607 }
00608
00609
00610
00611
00612
00613
00614
00615
00616 int getRescGrpForCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp, rescGrpInfo_t** myRescGrpInfo ) {
00617 int status;
00618 ruleExecInfo_t rei;
00619
00620
00621 initReiWithDataObjInp( &rei, rsComm, dataObjInp );
00622
00623 if (dataObjInp->oprType == REPLICATE_OPR) {
00624 status = applyRule ("acSetRescSchemeForRepl", NULL, &rei, NO_SAVE_REI);
00625
00626 } else {
00627 status = applyRule ("acSetRescSchemeForCreate", NULL, &rei, NO_SAVE_REI);
00628
00629 }
00630
00631 if( status < 0 ) {
00632 if (rei.status < 0) {
00633 status = rei.status;
00634 }
00635
00636 rodsLog( LOG_NOTICE,"getRescGrpForCreate:acSetRescSchemeForCreate error for %s,status=%d",
00637 dataObjInp->objPath, status);
00638
00639 return (status);
00640 }
00641
00642 if( rei.rgi == NULL ) {
00643
00644
00645
00646 (*myRescGrpInfo) = new rescGrpInfo_t;
00647 (*myRescGrpInfo)->cacheNext = 0;
00648 (*myRescGrpInfo)->next = 0;
00649 (*myRescGrpInfo)->rescInfo = new rescInfo_t;
00650
00651
00652 eirods::error set_err = eirods::set_default_resource( rsComm, "", "", &dataObjInp->condInput, *(*myRescGrpInfo) );
00653 if( !set_err.ok() ) {
00654 eirods::log( PASS( set_err ) );
00655 return SYS_INVALID_RESC_INPUT;
00656 }
00657
00658 } else {
00659 *myRescGrpInfo = rei.rgi;
00660 }
00661
00662 status = setRescQuota( rsComm, dataObjInp->objPath, myRescGrpInfo, dataObjInp->dataSize );
00663
00664 if( status == SYS_RESC_QUOTA_EXCEEDED ) {
00665 return SYS_RESC_QUOTA_EXCEEDED;
00666 }
00667
00668 #if 0 // JMC - legacy resource
00669 if( strstr( rei.statusStr, "random" ) == NULL ) {
00670
00671 sortRescByLocation (myRescGrpInfo);
00672 return 0;
00673
00674 } else {
00675 return 1;
00676 }
00677 #else
00678 return 0;
00679 #endif
00680 }
00681