00001
00002
00003
00004
00005
00006
00007 #ifndef windows_platform
00008
00009 #include <sys/types.h>
00010 #include <sys/wait.h>
00011 #endif
00012 #include "dataObjOpr.h"
00013 #include "objMetaOpr.h"
00014 #include "resource.h"
00015 #include "collection.h"
00016 #include "specColl.h"
00017 #include "physPath.h"
00018 #include "modDataObjMeta.h"
00019 #include "ruleExecSubmit.h"
00020 #include "ruleExecDel.h"
00021 #include "genQuery.h"
00022 #include "icatHighLevelRoutines.h"
00023 #include "reSysDataObjOpr.h"
00024 #include "miscUtil.h"
00025 #include "rodsClient.h"
00026 #include "rsIcatOpr.h"
00027
00028
00029
00030 #include "eirods_resource_backport.h"
00031 #include "eirods_log.h"
00032 #include "eirods_stacktrace.h"
00033
00034 int
00035 getDataObjInfo (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00036 dataObjInfo_t **dataObjInfoHead,char *accessPerm, int ignoreCondInput)
00037 {
00038 genQueryInp_t genQueryInp;
00039 genQueryOut_t *genQueryOut = NULL;
00040 int i, status;
00041 dataObjInfo_t *dataObjInfo;
00042 char condStr[MAX_NAME_LEN];
00043 char *tmpStr;
00044 sqlResult_t *dataId, *collId, *replNum, *version, *dataType, *dataSize,
00045 *rescGroupName, *rescName, *hierString, *filePath, *dataOwnerName, *dataOwnerZone,
00046 *replStatus, *statusString, *chksum, *dataExpiry, *dataMapId,
00047 *dataComments, *dataCreate, *dataModify, *dataMode, *dataName, *collName;
00048 char *tmpDataId, *tmpCollId, *tmpReplNum, *tmpVersion, *tmpDataType,
00049 *tmpDataSize, *tmpRescGroupName, *tmpRescName, *tmpHierString, *tmpFilePath,
00050 *tmpDataOwnerName, *tmpDataOwnerZone, *tmpReplStatus, *tmpStatusString,
00051 *tmpChksum, *tmpDataExpiry, *tmpDataMapId, *tmpDataComments,
00052 *tmpDataCreate, *tmpDataModify, *tmpDataMode, *tmpDataName, *tmpCollName;
00053 char accStr[LONG_NAME_LEN];
00054 int qcondCnt;
00055 int writeFlag;
00056
00057 *dataObjInfoHead = NULL;
00058
00059 qcondCnt = initDataObjInfoQuery (dataObjInp, &genQueryInp,
00060 ignoreCondInput);
00061
00062 if (qcondCnt < 0) {
00063 return (qcondCnt);
00064 }
00065
00066
00067 if (ignoreCondInput == 0 && (tmpStr =
00068 getValByKey (&dataObjInp->condInput, RESC_NAME_KW)) != NULL) {
00069 snprintf (condStr, NAME_LEN, "='%s'", tmpStr);
00070 addInxVal (&genQueryInp.sqlCondInp, COL_D_RESC_NAME, condStr);
00071 qcondCnt++;
00072 }
00073
00074
00075 if (false && ignoreCondInput == 0 &&
00076 (tmpStr = getValByKey (&dataObjInp->condInput, RESC_HIER_STR_KW)) != NULL) {
00077 snprintf (condStr, NAME_LEN, "='%s'", tmpStr);
00078 addInxVal (&genQueryInp.sqlCondInp, COL_D_RESC_HIER, condStr);
00079 qcondCnt++;
00080 }
00081
00082 addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);
00083 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
00084 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
00085 addInxIval (&genQueryInp.selectInp, COL_D_COLL_ID, 1);
00086 addInxIval (&genQueryInp.selectInp, COL_DATA_REPL_NUM, 1);
00087 addInxIval (&genQueryInp.selectInp, COL_DATA_VERSION, 1);
00088 addInxIval (&genQueryInp.selectInp, COL_DATA_TYPE_NAME, 1);
00089 addInxIval (&genQueryInp.selectInp, COL_DATA_SIZE, 1);
00090 addInxIval (&genQueryInp.selectInp, COL_D_RESC_GROUP_NAME, 1);
00091 addInxIval (&genQueryInp.selectInp, COL_D_RESC_NAME, 1);
00092 addInxIval (&genQueryInp.selectInp, COL_D_DATA_PATH, 1);
00093 addInxIval (&genQueryInp.selectInp, COL_D_OWNER_NAME, 1);
00094 addInxIval (&genQueryInp.selectInp, COL_D_OWNER_ZONE, 1);
00095 addInxIval (&genQueryInp.selectInp, COL_D_REPL_STATUS, 1);
00096 addInxIval (&genQueryInp.selectInp, COL_D_DATA_STATUS, 1);
00097 addInxIval (&genQueryInp.selectInp, COL_D_DATA_CHECKSUM, 1);
00098 addInxIval (&genQueryInp.selectInp, COL_D_EXPIRY, 1);
00099 addInxIval (&genQueryInp.selectInp, COL_D_MAP_ID, 1);
00100 addInxIval (&genQueryInp.selectInp, COL_D_COMMENTS, 1);
00101 addInxIval (&genQueryInp.selectInp, COL_D_CREATE_TIME, 1);
00102 addInxIval (&genQueryInp.selectInp, COL_D_MODIFY_TIME, 1);
00103 addInxIval (&genQueryInp.selectInp, COL_DATA_MODE, 1);
00104 addInxIval (&genQueryInp.selectInp, COL_D_RESC_HIER, 1);
00105
00106 if (accessPerm != NULL) {
00107 snprintf (accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.userName);
00108 addKeyVal (&genQueryInp.condInput, USER_NAME_CLIENT_KW, accStr);
00109
00110 snprintf (accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.rodsZone);
00111 addKeyVal (&genQueryInp.condInput, RODS_ZONE_CLIENT_KW, accStr);
00112
00113 snprintf (accStr, LONG_NAME_LEN, "%s", accessPerm);
00114 addKeyVal (&genQueryInp.condInput, ACCESS_PERMISSION_KW, accStr);
00115 }
00116
00117 genQueryInp.maxRows = MAX_SQL_ROWS;
00118
00119 status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00120
00121 clearGenQueryInp (&genQueryInp);
00122
00123 if (status < 0) {
00124 if (status !=CAT_NO_ROWS_FOUND) {
00125 rodsLog (LOG_NOTICE,
00126 "getDataObjInfo: rsGenQuery error, status = %d",
00127 status);
00128 }
00129 return (status);
00130 }
00131
00132 if (genQueryOut == NULL) {
00133 rodsLog (LOG_NOTICE,
00134 "getDataObjInfo: NULL genQueryOut");
00135 return (SYS_INTERNAL_NULL_INPUT_ERR);
00136 }
00137
00138 if ((dataOwnerName =
00139 getSqlResultByInx (genQueryOut, COL_D_OWNER_NAME)) == NULL) {
00140 rodsLog (LOG_NOTICE,
00141 "getDataObjInfo: getSqlResultByInx for COL_D_OWNER_NAME failed");
00142 return (UNMATCHED_KEY_OR_INDEX);
00143 }
00144
00145 if ((dataName =
00146 getSqlResultByInx (genQueryOut, COL_DATA_NAME)) == NULL) {
00147 rodsLog (LOG_NOTICE,
00148 "getDataObjInfo: getSqlResultByInx for COL_DATA_NAME failed");
00149 return (UNMATCHED_KEY_OR_INDEX);
00150 }
00151
00152 if ((collName =
00153 getSqlResultByInx (genQueryOut, COL_COLL_NAME)) == NULL) {
00154 rodsLog (LOG_NOTICE,
00155 "getDataObjInfo: getSqlResultByInx for COL_COLL_NAME failed");
00156 return (UNMATCHED_KEY_OR_INDEX);
00157 }
00158
00159 if ((dataId = getSqlResultByInx (genQueryOut, COL_D_DATA_ID)) == NULL) {
00160 rodsLog (LOG_NOTICE,
00161 "getDataObjInfo: getSqlResultByInx for COL_D_DATA_ID failed");
00162 return (UNMATCHED_KEY_OR_INDEX);
00163 }
00164
00165 if ((collId = getSqlResultByInx (genQueryOut, COL_D_COLL_ID)) == NULL) {
00166 rodsLog (LOG_NOTICE,
00167 "getDataObjInfo: getSqlResultByInx for COL_D_COLL_ID failed");
00168 return (UNMATCHED_KEY_OR_INDEX);
00169 }
00170
00171 if ((replNum = getSqlResultByInx (genQueryOut, COL_DATA_REPL_NUM)) ==
00172 NULL) {
00173 rodsLog (LOG_NOTICE,
00174 "getDataObjInfo: getSqlResultByInx for COL_DATA_REPL_NUM failed");
00175 return (UNMATCHED_KEY_OR_INDEX);
00176 }
00177
00178 if ((version = getSqlResultByInx (genQueryOut, COL_DATA_VERSION)) ==
00179 NULL) {
00180 rodsLog (LOG_NOTICE,
00181 "getDataObjInfo: getSqlResultByInx for COL_DATA_VERSION failed");
00182 return (UNMATCHED_KEY_OR_INDEX);
00183 }
00184
00185 if ((dataType = getSqlResultByInx (genQueryOut, COL_DATA_TYPE_NAME)) ==
00186 NULL) {
00187 rodsLog (LOG_NOTICE,
00188 "getDataObjInfo: getSqlResultByInx for COL_DATA_TYPE_NAME failed");
00189 return (UNMATCHED_KEY_OR_INDEX);
00190 }
00191
00192 if ((dataSize = getSqlResultByInx (genQueryOut, COL_DATA_SIZE)) == NULL) {
00193 rodsLog (LOG_NOTICE,
00194 "getDataObjInfo: getSqlResultByInx for COL_DATA_SIZE failed");
00195 return (UNMATCHED_KEY_OR_INDEX);
00196 }
00197
00198 if ((rescGroupName =
00199 getSqlResultByInx ( genQueryOut, COL_D_RESC_GROUP_NAME)) == NULL) {
00200 rodsLog (LOG_NOTICE,
00201 "getDataObjInfo:getSqlResultByInx for COL_D_RESC_GROUP_NAME failed");
00202 return (UNMATCHED_KEY_OR_INDEX);
00203 }
00204
00205 if ((rescName = getSqlResultByInx (genQueryOut, COL_D_RESC_NAME)) ==
00206 NULL) {
00207 rodsLog (LOG_NOTICE,
00208 "getDataObjInfo: getSqlResultByInx for COL_D_RESC_NAME failed");
00209 return (UNMATCHED_KEY_OR_INDEX);
00210 }
00211
00212 if ((hierString = getSqlResultByInx (genQueryOut, COL_D_RESC_HIER)) ==
00213 NULL) {
00214 rodsLog (LOG_NOTICE,
00215 "getDataObjInfo: getSqlResultByInx for COL_D_RESC_HIER failed");
00216 return (UNMATCHED_KEY_OR_INDEX);
00217 }
00218
00219 if ((filePath = getSqlResultByInx (genQueryOut, COL_D_DATA_PATH)) ==
00220 NULL) {
00221 rodsLog (LOG_NOTICE,
00222 "getDataObjInfo: getSqlResultByInx for COL_D_DATA_PATH failed");
00223 return (UNMATCHED_KEY_OR_INDEX);
00224 }
00225
00226 if ((dataOwnerZone =
00227 getSqlResultByInx (genQueryOut, COL_D_OWNER_ZONE)) == NULL) {
00228 rodsLog (LOG_NOTICE,
00229 "getDataObjInfo: getSqlResultByInx for COL_D_OWNER_ZONE failed");
00230 return (UNMATCHED_KEY_OR_INDEX);
00231 }
00232
00233 if ((replStatus =
00234 getSqlResultByInx (genQueryOut, COL_D_REPL_STATUS)) == NULL) {
00235 rodsLog (LOG_NOTICE,
00236 "getDataObjInfo: getSqlResultByInx for COL_D_REPL_STATUS failed");
00237 return (UNMATCHED_KEY_OR_INDEX);
00238 }
00239
00240 if ((statusString =
00241 getSqlResultByInx (genQueryOut, COL_D_DATA_STATUS)) == NULL) {
00242 rodsLog (LOG_NOTICE,
00243 "getDataObjInfo: getSqlResultByInx for COL_D_DATA_STATUS failed");
00244 return (UNMATCHED_KEY_OR_INDEX);
00245 }
00246
00247 if ((chksum =
00248 getSqlResultByInx (genQueryOut, COL_D_DATA_CHECKSUM)) == NULL) {
00249 rodsLog (LOG_NOTICE,
00250 "getDataObjInfo: getSqlResultByInx for COL_D_DATA_CHECKSUM failed");
00251 return (UNMATCHED_KEY_OR_INDEX);
00252 }
00253
00254 if ((dataExpiry =
00255 getSqlResultByInx (genQueryOut, COL_D_EXPIRY)) == NULL) {
00256 rodsLog (LOG_NOTICE,
00257 "getDataObjInfo: getSqlResultByInx for COL_D_EXPIRY failed");
00258 return (UNMATCHED_KEY_OR_INDEX);
00259 }
00260
00261 if ((dataMapId =
00262 getSqlResultByInx (genQueryOut, COL_D_MAP_ID)) == NULL) {
00263 rodsLog (LOG_NOTICE,
00264 "getDataObjInfo: getSqlResultByInx for COL_D_MAP_ID failed");
00265 return (UNMATCHED_KEY_OR_INDEX);
00266 }
00267
00268 if ((dataComments =
00269 getSqlResultByInx (genQueryOut, COL_D_COMMENTS)) == NULL) {
00270 rodsLog (LOG_NOTICE,
00271 "getDataObjInfo: getSqlResultByInx for COL_D_COMMENTS failed");
00272 return (UNMATCHED_KEY_OR_INDEX);
00273 }
00274
00275 if ((dataCreate =
00276 getSqlResultByInx (genQueryOut, COL_D_CREATE_TIME)) == NULL) {
00277 rodsLog (LOG_NOTICE,
00278 "getDataObjInfo: getSqlResultByInx for COL_D_CREATE_TIME failed");
00279 return (UNMATCHED_KEY_OR_INDEX);
00280 }
00281
00282 if ((dataModify =
00283 getSqlResultByInx (genQueryOut, COL_D_MODIFY_TIME)) == NULL) {
00284 rodsLog (LOG_NOTICE,
00285 "getDataObjInfo: getSqlResultByInx for COL_D_MODIFY_TIME failed");
00286 return (UNMATCHED_KEY_OR_INDEX);
00287 }
00288
00289 if ((dataMode =
00290 getSqlResultByInx (genQueryOut, COL_DATA_MODE)) == NULL) {
00291 rodsLog (LOG_NOTICE,
00292 "getDataObjInfo: getSqlResultByInx for COL_DATA_MODE failed");
00293 return (UNMATCHED_KEY_OR_INDEX);
00294 }
00295
00296 writeFlag = getWriteFlag (dataObjInp->openFlags);
00297
00298 for (i = 0;i < genQueryOut->rowCnt; i++) {
00299 dataObjInfo = (dataObjInfo_t *) malloc (sizeof (dataObjInfo_t));
00300 memset (dataObjInfo, 0, sizeof (dataObjInfo_t));
00301
00302 tmpDataId = &dataId->value[dataId->len * i];
00303 tmpCollId = &collId->value[collId->len * i];
00304 tmpReplNum = &replNum->value[replNum->len * i];
00305 tmpVersion = &version->value[version->len * i];
00306 tmpDataType = &dataType->value[dataType->len * i];
00307 tmpDataSize = &dataSize->value[dataSize->len * i];
00308 tmpRescGroupName = &rescGroupName->value[rescGroupName->len * i];
00309 tmpRescName = &rescName->value[rescName->len * i];
00310 tmpHierString = &hierString->value[hierString->len * i];
00311 tmpFilePath = &filePath->value[filePath->len * i];
00312 tmpDataOwnerName = &dataOwnerName->value[dataOwnerName->len * i];
00313 tmpDataOwnerZone = &dataOwnerZone->value[dataOwnerZone->len * i];
00314 tmpReplStatus = &replStatus->value[replStatus->len * i];
00315 tmpStatusString = &statusString->value[statusString->len * i];
00316 tmpChksum = &chksum->value[chksum->len * i];
00317 tmpDataExpiry = &dataExpiry->value[dataExpiry->len * i];
00318 tmpDataMapId = &dataMapId->value[dataMapId->len * i];
00319 tmpDataComments = &dataComments->value[dataComments->len * i];
00320 tmpDataCreate = &dataCreate->value[dataCreate->len * i];
00321 tmpDataModify = &dataModify->value[dataModify->len * i];
00322 tmpDataMode = &dataMode->value[dataMode->len * i];
00323 tmpDataName = &dataName->value[dataName->len * i];
00324 tmpCollName = &collName->value[collName->len * i];
00325
00326 snprintf (dataObjInfo->objPath, MAX_NAME_LEN, "%s/%s",tmpCollName, tmpDataName);
00327 rstrcpy (dataObjInfo->rescName, tmpRescName, NAME_LEN);
00328 rstrcpy (dataObjInfo->rescHier, tmpHierString, MAX_NAME_LEN);
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339 dataObjInfo->rescInfo = new rescInfo_t;
00340 eirods::error err = eirods::get_resc_info( dataObjInfo->rescName, *dataObjInfo->rescInfo );
00341 if( !err.ok() ) {
00342 std::stringstream msg;
00343 msg << "getDefaultLocalRescInfo - failed to get resource info";
00344 msg << dataObjInfo->rescName;
00345 eirods::log( PASS( false, -1, msg.str(), err ) );
00346 return err.code();
00347 }
00348
00349 std::string hier( tmpHierString );
00350 std::string resc( tmpRescName );
00351
00352 rstrcpy (dataObjInfo->rescGroupName, tmpRescGroupName, NAME_LEN);
00353 rstrcpy (dataObjInfo->dataType, tmpDataType, NAME_LEN);
00354 dataObjInfo->dataSize = strtoll (tmpDataSize, 0, 0);
00355 rstrcpy (dataObjInfo->chksum, tmpChksum, NAME_LEN);
00356 rstrcpy (dataObjInfo->version, tmpVersion, NAME_LEN);
00357 rstrcpy (dataObjInfo->filePath, tmpFilePath, MAX_NAME_LEN);
00358 rstrcpy (dataObjInfo->dataOwnerName, tmpDataOwnerName, NAME_LEN);
00359 rstrcpy (dataObjInfo->dataOwnerZone, tmpDataOwnerZone, NAME_LEN);
00360 dataObjInfo->replNum = atoi (tmpReplNum);
00361 dataObjInfo->replStatus = atoi (tmpReplStatus);
00362 rstrcpy (dataObjInfo->statusString, tmpStatusString, LONG_NAME_LEN);
00363 dataObjInfo->dataId = strtoll (tmpDataId, 0, 0);
00364 dataObjInfo->collId = strtoll (tmpCollId, 0, 0);
00365 dataObjInfo->dataMapId = atoi (tmpDataMapId);
00366 rstrcpy (dataObjInfo->dataComments, tmpDataComments, LONG_NAME_LEN);
00367 rstrcpy (dataObjInfo->dataExpiry, tmpDataExpiry, NAME_LEN);
00368 rstrcpy (dataObjInfo->dataCreate, tmpDataCreate, NAME_LEN);
00369 rstrcpy (dataObjInfo->dataModify, tmpDataModify, NAME_LEN);
00370 rstrcpy (dataObjInfo->dataMode, tmpDataMode, NAME_LEN);
00371 dataObjInfo->writeFlag = writeFlag;
00372
00373 dataObjInfo->next = 0;
00374
00375 queDataObjInfo (dataObjInfoHead, dataObjInfo, 1, 0);
00376
00377 }
00378
00379 freeGenQueryOut (&genQueryOut);
00380
00381 return (qcondCnt);
00382 }
00383
00384 int
00385 sortObjInfo (dataObjInfo_t **dataObjInfoHead,
00386 dataObjInfo_t **currentArchInfo, dataObjInfo_t **currentCacheInfo,
00387 dataObjInfo_t **oldArchInfo, dataObjInfo_t **oldCacheInfo,
00388 dataObjInfo_t **downCurrentInfo, dataObjInfo_t **downOldInfo)
00389 {
00390
00391 dataObjInfo_t *tmpDataObjInfo, *nextDataObjInfo;
00392
00393 int topFlag;
00394 dataObjInfo_t *currentBundleInfo = NULL;
00395 dataObjInfo_t *oldBundleInfo = NULL;
00396
00397 *currentArchInfo = *currentCacheInfo = *oldArchInfo = *oldCacheInfo = NULL;
00398 *downCurrentInfo = *downOldInfo = NULL;
00399
00400 tmpDataObjInfo = *dataObjInfoHead;
00401
00402 while (tmpDataObjInfo != NULL) {
00403
00404 nextDataObjInfo = tmpDataObjInfo->next;
00405 tmpDataObjInfo->next = NULL;
00406
00407
00408 if (tmpDataObjInfo->rescInfo == NULL ||
00409 tmpDataObjInfo->rescInfo->rodsServerHost == NULL) {
00410 topFlag = 0;
00411
00412 } else if (tmpDataObjInfo->rescInfo->rescStatus == INT_RESC_STATUS_DOWN) {
00413
00414 if (tmpDataObjInfo->replStatus > 0) {
00415 queDataObjInfo (downCurrentInfo, tmpDataObjInfo, 1, 1);
00416 } else {
00417 queDataObjInfo (downOldInfo, tmpDataObjInfo, 1, 1);
00418 }
00419
00420 tmpDataObjInfo = nextDataObjInfo;
00421
00422 continue;
00423 } else {
00424 rodsServerHost_t *rodsServerHost = (rodsServerHost_t *) tmpDataObjInfo->rescInfo->rodsServerHost;
00425
00426 if ( rodsServerHost && rodsServerHost->localFlag != LOCAL_HOST) {
00427 topFlag = 0;
00428 } else {
00429
00430 topFlag = 1;
00431 }
00432 }
00433
00434 std::string class_type;
00435 eirods::error prop_err = eirods::get_resource_property<std::string>( tmpDataObjInfo->rescInfo->rescName, "class", class_type );
00436
00437 if (tmpDataObjInfo->replStatus > 0) {
00438 #if 0 // JMC - legacy resource
00439 if (RescClass[rescClassInx].classType == ARCHIVAL_CL) {
00440 queDataObjInfo (currentArchInfo, tmpDataObjInfo, 1, topFlag);
00441 } else if (RescClass[rescClassInx].classType == COMPOUND_CL) {
00442 queDataObjInfo (¤tCompInfo, tmpDataObjInfo, 1, topFlag);
00443 } else if (RescClass[rescClassInx].classType == BUNDLE_CL) {
00444 queDataObjInfo (¤tBundleInfo, tmpDataObjInfo, 1, topFlag);
00445 } else {
00446 queDataObjInfo (currentCacheInfo, tmpDataObjInfo, 1, topFlag);
00447 }
00448 #else
00449 if( "archive" == class_type ) {
00450 queDataObjInfo (currentArchInfo, tmpDataObjInfo, 1, topFlag);
00451 } else if( "compound" == class_type ) {
00452 rodsLog( LOG_ERROR, "sortObj :: class_type == compound" );
00453 } else if( "bundle" == class_type ) {
00454 queDataObjInfo (¤tBundleInfo, tmpDataObjInfo, 1, topFlag);
00455 } else {
00456 queDataObjInfo (currentCacheInfo, tmpDataObjInfo, 1, topFlag);
00457 }
00458 #endif // JMC - legacy resource
00459 } else {
00460 #if 0 // JMC - legacy resource
00461 if (RescClass[rescClassInx].classType == ARCHIVAL_CL) {
00462 queDataObjInfo (oldArchInfo, tmpDataObjInfo, 1, topFlag);
00463 } else if (RescClass[rescClassInx].classType == COMPOUND_CL) {
00464 queDataObjInfo (&oldCompInfo, tmpDataObjInfo, 1, topFlag);
00465 } else if (RescClass[rescClassInx].classType == BUNDLE_CL) {
00466 queDataObjInfo (&oldBundleInfo, tmpDataObjInfo, 1, topFlag);
00467 } else {
00468 queDataObjInfo (oldCacheInfo, tmpDataObjInfo, 1, topFlag);
00469 }
00470 #else
00471 if( "archive" == class_type ) {
00472 queDataObjInfo (oldArchInfo, tmpDataObjInfo, 1, topFlag);
00473 } else if( "compound" == class_type ) {
00474 rodsLog( LOG_ERROR, "sortObj :: class_type == compound" );
00475 } else if( "bundle" == class_type ) {
00476 queDataObjInfo (&oldBundleInfo, tmpDataObjInfo, 1, topFlag);
00477 } else {
00478 queDataObjInfo (oldCacheInfo, tmpDataObjInfo, 1, topFlag);
00479 }
00480 #endif // JMC - legacy resource
00481
00482 }
00483 tmpDataObjInfo = nextDataObjInfo;
00484 }
00485
00486
00487
00488 queDataObjInfo (oldArchInfo, oldBundleInfo, 0, 0);
00489
00490 queDataObjInfo (currentArchInfo, currentBundleInfo, 0, 0);
00491 return (0);
00492 }
00493
00494
00495
00496
00497
00498
00499
00500 int
00501 sortObjInfoForOpen (rsComm_t *rsComm, dataObjInfo_t **dataObjInfoHead,
00502 keyValPair_t *condInput, int writeFlag)
00503 {
00504
00505 dataObjInfo_t *currentArchInfo, *currentCacheInfo, *oldArchInfo,
00506 *oldCacheInfo, *downCurrentInfo, *downOldInfo;
00507 int status = 0;
00508 sortObjInfo (dataObjInfoHead, ¤tArchInfo, ¤tCacheInfo,
00509 &oldArchInfo, &oldCacheInfo, &downCurrentInfo, &downOldInfo);
00510
00511 *dataObjInfoHead = currentCacheInfo;
00512 queDataObjInfo (dataObjInfoHead, currentArchInfo, 0, 0);
00513 if (writeFlag == 0) {
00514
00515 if (*dataObjInfoHead != NULL) {
00516
00517 freeAllDataObjInfo (oldCacheInfo);
00518 freeAllDataObjInfo (oldArchInfo);
00519 } else if (downCurrentInfo != NULL) {
00520
00521
00522 freeAllDataObjInfo (oldCacheInfo);
00523 freeAllDataObjInfo (oldArchInfo);
00524 status = SYS_RESC_IS_DOWN;
00525 } else {
00526
00527 queDataObjInfo (dataObjInfoHead, oldCacheInfo, 0, 0);
00528 queDataObjInfo (dataObjInfoHead, oldArchInfo, 0, 0);
00529 }
00530 freeAllDataObjInfo (downCurrentInfo);
00531 freeAllDataObjInfo (downOldInfo);
00532 } else {
00533 char *rescName;
00534 queDataObjInfo (dataObjInfoHead, oldCacheInfo, 0, 0);
00535 queDataObjInfo (dataObjInfoHead, oldArchInfo, 0, 0);
00536
00537 if (*dataObjInfoHead == NULL) {
00538
00539 std::string resc_name;
00540 eirods::error name_err = eirods::resolve_resource_name( "", condInput, resc_name );
00541 if( !name_err.ok() ) {
00542 freeAllDataObjInfo (downCurrentInfo);
00543 freeAllDataObjInfo (downOldInfo);
00544 status = SYS_RESC_IS_DOWN;
00545
00546 } else {
00547 int resc_status = -1;
00548 eirods::error prop_err = eirods::get_resource_property<int>( resc_name, "status", resc_status );
00549
00550 if( resc_status == INT_RESC_STATUS_DOWN ) {
00551 freeAllDataObjInfo (downCurrentInfo);
00552 freeAllDataObjInfo (downOldInfo);
00553 status = SYS_RESC_IS_DOWN;
00554 } else {
00555 queDataObjInfo (dataObjInfoHead, downCurrentInfo, 0, 0);
00556 queDataObjInfo (dataObjInfoHead, downOldInfo, 0, 0);
00557 }
00558 }
00559 } else {
00560 freeAllDataObjInfo (downCurrentInfo);
00561 freeAllDataObjInfo (downOldInfo);
00562 if ((rescName = getValByKey (condInput, DEST_RESC_NAME_KW)) != NULL ||
00563 (rescName = getValByKey (condInput, DEF_RESC_NAME_KW)) != NULL ||
00564 (rescName = getValByKey (condInput, BACKUP_RESC_NAME_KW)) != NULL) {
00565
00566 requeDataObjInfoByResc (dataObjInfoHead, rescName, writeFlag,1);
00567 }
00568 }
00569 }
00570 return (status);
00571
00572 return 0;
00573 }
00574
00575 int
00576 getNumDataObjInfo (dataObjInfo_t *dataObjInfoHead)
00577 {
00578 dataObjInfo_t *tmpDataObjInfo;
00579 int numInfo = 0;
00580
00581 tmpDataObjInfo = dataObjInfoHead;
00582 while (tmpDataObjInfo != NULL) {
00583 numInfo++;
00584 tmpDataObjInfo = tmpDataObjInfo->next;
00585 }
00586 return (numInfo);
00587 }
00588
00589 int
00590 sortDataObjInfoRandom (dataObjInfo_t **dataObjInfoHead)
00591 {
00592 dataObjInfo_t *myDataObjInfo[50];
00593 dataObjInfo_t *tmpDataObjInfo;
00594 int i, j, tmpCnt, order;
00595 int numInfo = getNumDataObjInfo (*dataObjInfoHead);
00596
00597 if (numInfo <= 1) {
00598 return (0);
00599 }
00600
00601 if (numInfo > 50) {
00602 rodsLog (LOG_NOTICE,
00603 "sortDataObjInfoRandom: numInfo %d > 50, setting it to 50", numInfo);
00604 numInfo = 50;
00605 }
00606
00607 memset (myDataObjInfo, 0, numInfo * sizeof (rescGrpInfo_t *));
00608
00609
00610 tmpCnt = numInfo;
00611 tmpDataObjInfo = *dataObjInfoHead;
00612 while (tmpDataObjInfo != NULL) {
00613 if (tmpCnt > 1) {
00614 order = random() % tmpCnt;
00615 } else {
00616 order = 0;
00617 }
00618 for (i = 0, j = 0; i < numInfo; i ++) {
00619 if (myDataObjInfo[i] == NULL) {
00620 if (order <= j) {
00621 myDataObjInfo[i] = tmpDataObjInfo;
00622 break;
00623 }
00624 j ++;
00625 }
00626 }
00627 tmpCnt --;
00628 tmpDataObjInfo = tmpDataObjInfo->next;
00629 }
00630
00631
00632
00633 *dataObjInfoHead = NULL;
00634 for (i = 0; i < numInfo; i ++) {
00635 queDataObjInfo (dataObjInfoHead, myDataObjInfo[i], 1, 1);
00636 }
00637
00638 return (0);
00639 }
00640
00641
00642
00643
00644
00645
00646
00647
00648 int
00649 requeDataObjInfoByResc (dataObjInfo_t **dataObjInfoHead,
00650 char *preferredResc, int writeFlag, int topFlag)
00651 {
00652
00653 dataObjInfo_t *tmpDataObjInfo, *prevDataObjInfo;
00654 int status = -1;
00655
00656 if (preferredResc == NULL || *dataObjInfoHead == NULL) {
00657 return (0);
00658 }
00659
00660 tmpDataObjInfo = *dataObjInfoHead;
00661 if (tmpDataObjInfo->next == NULL) {
00662
00663 if (strcmp (preferredResc, tmpDataObjInfo->rescInfo->rescName) == 0 ||
00664 strcmp (preferredResc, tmpDataObjInfo->rescGroupName) == 0) {
00665 return (0);
00666 } else {
00667 return (-1);
00668 }
00669 }
00670 prevDataObjInfo = NULL;
00671 while (tmpDataObjInfo != NULL) {
00672 if (tmpDataObjInfo->rescInfo != NULL) {
00673 if (strcmp (preferredResc, tmpDataObjInfo->rescInfo->rescName)
00674 == 0 || strcmp (preferredResc, tmpDataObjInfo->rescGroupName)
00675 == 0) {
00676 if (writeFlag > 0 || tmpDataObjInfo->replStatus > 0) {
00677 if (prevDataObjInfo != NULL) {
00678 prevDataObjInfo->next = tmpDataObjInfo->next;
00679 queDataObjInfo (dataObjInfoHead, tmpDataObjInfo, 1,
00680 topFlag);
00681 }
00682 if (topFlag > 0) {
00683 return (0);
00684 } else {
00685 status = 0;
00686 }
00687 }
00688 }
00689 }
00690 prevDataObjInfo = tmpDataObjInfo;
00691 tmpDataObjInfo = tmpDataObjInfo->next;
00692 }
00693
00694 return (status);
00695 }
00696
00697 int
00698 requeDataObjInfoByReplNum (dataObjInfo_t **dataObjInfoHead, int replNum)
00699 {
00700 dataObjInfo_t *tmpDataObjInfo, *prevDataObjInfo;
00701 int status = -1;
00702
00703 if (dataObjInfoHead == NULL || *dataObjInfoHead == NULL) {
00704 return (-1);
00705 }
00706
00707 tmpDataObjInfo = *dataObjInfoHead;
00708 if (tmpDataObjInfo->next == NULL) {
00709
00710 if (replNum == tmpDataObjInfo->replNum) {
00711 return (0);
00712 } else {
00713 return (-1);
00714 }
00715 }
00716 prevDataObjInfo = NULL;
00717 while (tmpDataObjInfo != NULL) {
00718 if (replNum == tmpDataObjInfo->replNum) {
00719 if (prevDataObjInfo != NULL) {
00720 prevDataObjInfo->next = tmpDataObjInfo->next;
00721 queDataObjInfo (dataObjInfoHead, tmpDataObjInfo, 1, 1);
00722 }
00723 status = 0;
00724 break;
00725 }
00726 prevDataObjInfo = tmpDataObjInfo;
00727 tmpDataObjInfo = tmpDataObjInfo->next;
00728 }
00729
00730 return (status);
00731 }
00732
00733 dataObjInfo_t *
00734 chkCopyInResc (dataObjInfo_t *dataObjInfoHead, rescGrpInfo_t *myRescGrpInfo, const char* destRescHier)
00735 {
00736 rescGrpInfo_t *tmpRescGrpInfo;
00737 rescInfo_t *tmpRescInfo;
00738 dataObjInfo_t *tmpDataObjInfo;
00739
00740 tmpDataObjInfo = dataObjInfoHead;
00741 while (tmpDataObjInfo != NULL) {
00742 tmpRescGrpInfo = myRescGrpInfo;
00743 while (tmpRescGrpInfo != NULL) {
00744 tmpRescInfo = tmpRescGrpInfo->rescInfo;
00745
00746
00747 if (strcmp (tmpDataObjInfo->rescInfo->rescName, tmpRescInfo->rescName) == 0 &&
00748 (destRescHier == NULL || strcmp(tmpDataObjInfo->rescHier, destRescHier) == 0)) {
00749 return (tmpDataObjInfo);
00750 }
00751 tmpRescGrpInfo = tmpRescGrpInfo->next;
00752 }
00753 tmpDataObjInfo = tmpDataObjInfo->next;
00754 }
00755 return (NULL);
00756 }
00757
00758
00759
00760
00761
00762
00763
00764
00765 int
00766 matchAndTrimRescGrp (dataObjInfo_t **dataObjInfoHead,
00767 rescGrpInfo_t **rescGrpInfoHead, int trimjFlag,
00768 dataObjInfo_t **trimmedDataObjInfo)
00769 {
00770 rescGrpInfo_t *tmpRescGrpInfo;
00771 rescGrpInfo_t *prevRescGrpInfo;
00772 rescInfo_t *tmpRescInfo;
00773 dataObjInfo_t *tmpDataObjInfo, *prevDataObjInfo, *nextDataObjInfo;
00774 int matchFlag;
00775 char rescGroupName[NAME_LEN];
00776
00777 if (trimmedDataObjInfo != NULL) *trimmedDataObjInfo = NULL;
00778
00779 if (*rescGrpInfoHead != NULL) {
00780 rstrcpy (rescGroupName, (*rescGrpInfoHead)->rescGroupName, NAME_LEN);
00781 } else {
00782 rescGroupName[0] = '\0';
00783 }
00784
00785 tmpDataObjInfo = *dataObjInfoHead;
00786 prevDataObjInfo = NULL;
00787
00788 while( tmpDataObjInfo != NULL ) {
00789 matchFlag = 0;
00790 nextDataObjInfo = tmpDataObjInfo->next;
00791 tmpRescGrpInfo = *rescGrpInfoHead;
00792 prevRescGrpInfo = NULL;
00793
00794 while (tmpRescGrpInfo != NULL) {
00795 tmpRescInfo = tmpRescGrpInfo->rescInfo;
00796 if (strcmp (tmpDataObjInfo->rescInfo->rescName,tmpRescInfo->rescName) == 0) {
00797 matchFlag = 1;
00798 break;
00799
00800 }
00801
00802 prevRescGrpInfo = tmpRescGrpInfo;
00803 tmpRescGrpInfo = tmpRescGrpInfo->next;
00804
00805 }
00806
00807 if (matchFlag == 1) {
00808 if (trimjFlag & TRIM_MATCHED_RESC_INFO) {
00809 if (tmpRescGrpInfo == *rescGrpInfoHead) {
00810 *rescGrpInfoHead = tmpRescGrpInfo->next;
00811
00812 } else {
00813 prevRescGrpInfo->next = tmpRescGrpInfo->next;
00814
00815 }
00816
00817 free (tmpRescGrpInfo);
00818
00819 } else if( trimjFlag & REQUE_MATCHED_RESC_INFO ) {
00820 if (tmpRescGrpInfo->next != NULL) {
00821 #if 0 // JMC - legacy resource
00822
00823 if (tmpRescGrpInfo == *rescGrpInfoHead) {
00824 *rescGrpInfoHead = tmpRescGrpInfo->next;
00825
00826 } else {
00827 prevRescGrpInfo->next = tmpRescGrpInfo->next;
00828
00829 }
00830
00831 queRescGrp (rescGrpInfoHead, tmpRescGrpInfo, BOTTOM_FLAG);
00832
00833 #else
00834 rodsLog( LOG_ERROR, "matchAndTrimRescGrp - calling REQUE_MATCHED_RESC_INFO with non null next ptr." );
00835 #endif
00836 }
00837
00838 }
00839
00840 if (trimjFlag & TRIM_MATCHED_OBJ_INFO) {
00841 if (tmpDataObjInfo == *dataObjInfoHead) {
00842 *dataObjInfoHead = tmpDataObjInfo->next;
00843
00844 } else {
00845 prevDataObjInfo->next = tmpDataObjInfo->next;
00846
00847 }
00848
00849 if (trimmedDataObjInfo != NULL) {
00850 queDataObjInfo (trimmedDataObjInfo, tmpDataObjInfo, 1, 0);
00851
00852 } else {
00853 free (tmpDataObjInfo);
00854
00855 }
00856
00857 } else {
00858 prevDataObjInfo = tmpDataObjInfo;
00859
00860 }
00861
00862 } else {
00863
00864 if( ( trimjFlag & TRIM_UNMATCHED_OBJ_INFO ) ||
00865 ( ( trimjFlag & TRIM_MATCHED_OBJ_INFO ) &&
00866 strlen( rescGroupName ) > 0 &&
00867 strcmp( tmpDataObjInfo->rescGroupName, rescGroupName ) == 0 ) ) {
00868
00869 if (tmpDataObjInfo == *dataObjInfoHead) {
00870 *dataObjInfoHead = tmpDataObjInfo->next;
00871
00872 } else {
00873 prevDataObjInfo->next = tmpDataObjInfo->next;
00874
00875 }
00876
00877 if (trimmedDataObjInfo != NULL) {
00878 queDataObjInfo (trimmedDataObjInfo, tmpDataObjInfo, 1, 0);
00879
00880 } else {
00881 free (tmpDataObjInfo);
00882
00883 }
00884
00885 } else {
00886 prevDataObjInfo = tmpDataObjInfo;
00887
00888 }
00889
00890 }
00891
00892 tmpDataObjInfo = nextDataObjInfo;
00893
00894 }
00895
00896 return (0);
00897 }
00898
00899
00900
00901
00902
00903
00904
00905 int
00906 sortObjInfoForRepl (dataObjInfo_t **dataObjInfoHead,
00907 dataObjInfo_t **oldDataObjInfoHead, int deleteOldFlag)
00908 {
00909
00910 dataObjInfo_t *currentArchInfo, *currentCacheInfo, *oldArchInfo,
00911 *oldCacheInfo, *downCurrentInfo, *downOldInfo;
00912
00913
00914 sortObjInfo( dataObjInfoHead, ¤tArchInfo, ¤tCacheInfo,
00915 &oldArchInfo, &oldCacheInfo, &downCurrentInfo, &downOldInfo);
00916
00917
00918 freeAllDataObjInfo (downOldInfo);
00919 *dataObjInfoHead = currentCacheInfo;
00920 queDataObjInfo (dataObjInfoHead, currentArchInfo, 0, 0);
00921 queDataObjInfo (dataObjInfoHead, downCurrentInfo, 0, 0);
00922 if (*dataObjInfoHead != NULL) {
00923 if (deleteOldFlag == 0) {
00924
00925
00926 *oldDataObjInfoHead = oldCacheInfo;
00927 queDataObjInfo (oldDataObjInfoHead, oldArchInfo, 0, 0);
00928 } else {
00929 freeAllDataObjInfo (oldCacheInfo);
00930 freeAllDataObjInfo (oldArchInfo);
00931 }
00932 } else {
00933 queDataObjInfo (dataObjInfoHead, oldCacheInfo, 0, 0);
00934 queDataObjInfo (dataObjInfoHead, oldArchInfo, 0, 0);
00935 }
00936 if (*dataObjInfoHead == NULL)
00937 return SYS_RESC_IS_DOWN;
00938 else
00939
00940 return (0);
00941 }
00942
00943 #if 0 // JMC - UNUSED
00944
00945
00946
00947
00948 int
00949 dataObjExist (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
00950 {
00951 genQueryInp_t genQueryInp;
00952 genQueryOut_t *genQueryOut = NULL;
00953 int status;
00954
00955 status = initDataObjInfoQuery (dataObjInp, &genQueryInp, 0);
00956
00957 if (status < 0) {
00958 return (status);
00959 }
00960
00961 addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);
00962 genQueryInp.maxRows = MAX_SQL_ROWS;
00963
00964 status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00965
00966 clearGenQueryInp (&genQueryInp);
00967 freeGenQueryOut (&genQueryOut);
00968
00969 if (status < 0) {
00970 return (0);
00971 } else {
00972 return (1);
00973 }
00974 }
00975 #endif // JMC - UNUSED
00976
00977
00978
00979
00980
00981 int
00982 initDataObjInfoQuery (dataObjInp_t *dataObjInp, genQueryInp_t *genQueryInp,
00983 int ignoreCondInput)
00984 {
00985 char myColl[MAX_NAME_LEN], myData[MAX_NAME_LEN];
00986 char condStr[MAX_NAME_LEN];
00987 char *tmpStr;
00988 int status;
00989 int qcondCnt = 0;
00990
00991 memset (genQueryInp, 0, sizeof (genQueryInp_t));
00992
00993 if ((tmpStr = getValByKey (&dataObjInp->condInput, QUERY_BY_DATA_ID_KW))
00994 == NULL) {
00995 memset (myColl, 0, MAX_NAME_LEN);
00996 memset (myData, 0, MAX_NAME_LEN);
00997
00998 if ((status = splitPathByKey (
00999 dataObjInp->objPath, myColl, myData, '/')) < 0) {
01000 rodsLog (LOG_NOTICE,
01001 "initDataObjInfoQuery: splitPathByKey for %s error, status = %d",
01002 dataObjInp->objPath, status);
01003 return (status);
01004 }
01005 snprintf (condStr, MAX_NAME_LEN, "='%s'", myColl);
01006 addInxVal (&genQueryInp->sqlCondInp, COL_COLL_NAME, condStr);
01007 snprintf (condStr, MAX_NAME_LEN, "='%s'", myData);
01008 addInxVal (&genQueryInp->sqlCondInp, COL_DATA_NAME, condStr);
01009 } else {
01010 snprintf (condStr, MAX_NAME_LEN, "='%s'", tmpStr);
01011 addInxVal (&genQueryInp->sqlCondInp, COL_D_DATA_ID, condStr);
01012 }
01013
01014 if (ignoreCondInput == 0 && (tmpStr =
01015 getValByKey (&dataObjInp->condInput, REPL_NUM_KW)) != NULL) {
01016 snprintf (condStr, NAME_LEN, "='%s'", tmpStr);
01017 addInxVal (&genQueryInp->sqlCondInp, COL_DATA_REPL_NUM, condStr);
01018 qcondCnt++;
01019 }
01020
01021 return (qcondCnt);
01022 }
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032 int
01033 chkOrphanFile (rsComm_t *rsComm, char *filePath, char *rescName,
01034 dataObjInfo_t *dataObjInfo)
01035 {
01036 genQueryInp_t genQueryInp;
01037 genQueryOut_t *genQueryOut = NULL;
01038 int status;
01039 char condStr[MAX_NAME_LEN];
01040
01041 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
01042
01043 snprintf (condStr, MAX_NAME_LEN, "='%s'", filePath);
01044 addInxVal (&genQueryInp.sqlCondInp, COL_D_DATA_PATH, condStr);
01045 snprintf (condStr, MAX_NAME_LEN, "='%s'", rescName);
01046 addInxVal (&genQueryInp.sqlCondInp, COL_D_RESC_NAME, condStr);
01047
01048 addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);
01049 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
01050 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
01051 addInxIval (&genQueryInp.selectInp, COL_DATA_REPL_NUM, 1);
01052 addInxIval (&genQueryInp.selectInp, COL_D_RESC_HIER, 1);
01053
01054 genQueryInp.maxRows = MAX_SQL_ROWS;
01055
01056 status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
01057
01058 clearGenQueryInp (&genQueryInp);
01059 if (status < 0) {
01060 if (status == CAT_NO_ROWS_FOUND) {
01061 rsComm->perfStat.orphanCnt ++;
01062 return (1);
01063 } else {
01064 rodsLog (LOG_ERROR,
01065 "chkOrphanFile: rsGenQuery error for %s, status = %d",
01066 filePath, status);
01067
01068
01069 return (status);
01070 }
01071 } else {
01072 sqlResult_t *dataId, *replNum, *dataName, *collName, *rescHier;
01073 rsComm->perfStat.nonOrphanCnt ++;
01074
01075 if ((collName =
01076 getSqlResultByInx (genQueryOut, COL_COLL_NAME)) == NULL) {
01077 rodsLog (LOG_NOTICE,
01078 "chkOrphanFile: getSqlResultByInx for COL_COLL_NAME failed");
01079 return (UNMATCHED_KEY_OR_INDEX);
01080 }
01081
01082 if ((dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME))
01083 == NULL) {
01084 rodsLog (LOG_NOTICE,
01085 "chkOrphanFile: getSqlResultByInx for COL_DATA_NAME failed");
01086 return (UNMATCHED_KEY_OR_INDEX);
01087 }
01088
01089 if ((dataId = getSqlResultByInx (genQueryOut, COL_D_DATA_ID)) == NULL) {
01090 rodsLog (LOG_NOTICE,
01091 "chkOrphanFile: getSqlResultByInx for COL_D_DATA_ID failed");
01092 return (UNMATCHED_KEY_OR_INDEX);
01093 }
01094
01095 if ((replNum = getSqlResultByInx (genQueryOut, COL_DATA_REPL_NUM)) ==
01096 NULL) {
01097 rodsLog (LOG_NOTICE,
01098 "chkOrphanFile: getSqlResultByInx for COL_DATA_REPL_NUM failed");
01099 return (UNMATCHED_KEY_OR_INDEX);
01100 }
01101
01102 if ((rescHier = getSqlResultByInx (genQueryOut, COL_D_RESC_HIER)) ==
01103 NULL) {
01104 rodsLog (LOG_NOTICE,
01105 "chkOrphanFile: getSqlResultByInx for COL_D_RESC_HIER failed");
01106 return (UNMATCHED_KEY_OR_INDEX);
01107 }
01108
01109 if (dataObjInfo != NULL) {
01110 dataObjInfo->dataId = strtoll (dataId->value, 0, 0);
01111 dataObjInfo->replNum = atoi (replNum->value);
01112 snprintf (dataObjInfo->objPath, MAX_NAME_LEN, "%s/%s",
01113 collName->value, dataName->value);
01114 rstrcpy(dataObjInfo->rescHier, rescHier->value, MAX_NAME_LEN);
01115 }
01116
01117 freeGenQueryOut (&genQueryOut);
01118
01119 return (0);
01120 }
01121 }
01122
01123
01124
01125
01126
01127
01128
01129
01130 int
01131 chkOrphanDir (rsComm_t *rsComm, char *dirPath, char *rescName)
01132 {
01133 #ifndef USE_BOOST_FS
01134 DIR *dirPtr;
01135 struct dirent *myDirent;
01136 struct stat statbuf;
01137 #endif
01138 char subfilePath[MAX_NAME_LEN];
01139 int savedStatus = 1;
01140 int status = 0;
01141
01142 #ifdef USE_BOOST_FS
01143 path srcDirPath (dirPath);
01144 if (!exists(srcDirPath) || !is_directory(srcDirPath)) {
01145 #else
01146 dirPtr = opendir (dirPath);
01147 if (dirPtr == NULL) {
01148 #endif
01149 rodsLog (LOG_ERROR,
01150 "chkOrphanDir: opendir error for %s, errno = %d",
01151 dirPath, errno);
01152 return (UNIX_FILE_OPENDIR_ERR - errno);
01153 }
01154 #ifdef USE_BOOST_FS
01155 directory_iterator end_itr;
01156 for (directory_iterator itr(srcDirPath); itr != end_itr;++itr) {
01157 path p = itr->path();
01158 snprintf (subfilePath, MAX_NAME_LEN, "%s",
01159 p.c_str ());
01160 #else
01161 while ((myDirent = readdir (dirPtr)) != NULL) {
01162 if (strcmp (myDirent->d_name, ".") == 0 ||
01163 strcmp (myDirent->d_name, "..") == 0) {
01164 continue;
01165 }
01166 snprintf (subfilePath, MAX_NAME_LEN, "%s/%s",
01167 dirPath, myDirent->d_name);
01168 #endif
01169
01170 #ifdef USE_BOOST_FS
01171 if (!exists (p)) {
01172 #else
01173 status = stat (subfilePath, &statbuf);
01174
01175 if (status != 0) {
01176 #endif
01177 rodsLog (LOG_ERROR,
01178 "chkOrphanDir: stat error for %s, errno = %d",
01179 subfilePath, errno);
01180 savedStatus = UNIX_FILE_STAT_ERR - errno;
01181 continue;
01182 }
01183 #ifdef USE_BOOST_FS
01184 if (is_directory (p)) {
01185 #else
01186 if ((statbuf.st_mode & S_IFDIR) != 0) {
01187 #endif
01188 status = chkOrphanDir (rsComm, subfilePath, rescName);
01189 #ifdef USE_BOOST_FS
01190 } else if (is_regular_file (p)) {
01191 #else
01192 } else if ((statbuf.st_mode & S_IFREG) != 0) {
01193 #endif
01194 status = chkOrphanFile (rsComm, subfilePath, rescName, NULL);
01195 }
01196 if (status == 0) {
01197
01198 #ifndef USE_BOOST_FS
01199 closedir (dirPtr);
01200 #endif
01201 return status;
01202 } else if (status < 0) {
01203 savedStatus = status;
01204 }
01205 }
01206 #ifndef USE_BOOST_FS
01207 closedir (dirPtr);
01208 #endif
01209 return savedStatus;
01210 }
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226 int
01227 resolveSingleReplCopy ( dataObjInfo_t **dataObjInfoHead,
01228 dataObjInfo_t **oldDataObjInfoHead,
01229 rescGrpInfo_t **destRescGrpInfo,
01230 dataObjInfo_t **destDataObjInfo,
01231 keyValPair_t *condInput ) {
01232 int status;
01233 dataObjInfo_t *matchedDataObjInfo = NULL;
01234 dataObjInfo_t *matchedOldDataObjInfo = NULL;
01235
01236
01237 status = matchDataObjInfoByCondInput (dataObjInfoHead, oldDataObjInfoHead,
01238 condInput, &matchedDataObjInfo, &matchedOldDataObjInfo);
01239
01240 if (status < 0) {
01241 return status;
01242 }
01243
01244 if (matchedDataObjInfo != NULL) {
01245
01246 queDataObjInfo (dataObjInfoHead, matchedDataObjInfo, 0, 1);
01247 queDataObjInfo (oldDataObjInfoHead, matchedOldDataObjInfo, 0, 1);
01248 } else if (matchedOldDataObjInfo != NULL) {
01249
01250
01251 queDataObjInfo (oldDataObjInfoHead, *dataObjInfoHead, 0, 1);
01252 *dataObjInfoHead = matchedOldDataObjInfo;
01253 }
01254
01255 if ((*destRescGrpInfo)->next == NULL ||
01256 strlen ((*destRescGrpInfo)->rescGroupName) == 0) {
01257
01258 char* destRescHier = getValByKey(condInput, DEST_RESC_HIER_STR_KW);
01259 if ((*destDataObjInfo = chkCopyInResc (*dataObjInfoHead,
01260 *destRescGrpInfo,
01261 destRescHier)) != NULL) {
01262
01263 *destDataObjInfo = NULL;
01264 return (HAVE_GOOD_COPY);
01265 }
01266 } else {
01267
01268 matchAndTrimRescGrp (dataObjInfoHead, destRescGrpInfo,
01269 TRIM_MATCHED_RESC_INFO, NULL);
01270 if (*destRescGrpInfo == NULL) {
01271
01272 return (HAVE_GOOD_COPY);
01273 }
01274 }
01275
01276 if (getValByKey (condInput, ALL_KW) != NULL) {
01277 dataObjInfo_t *trimmedDataObjInfo = NULL;
01278
01279
01280 matchAndTrimRescGrp (oldDataObjInfoHead, destRescGrpInfo,
01281 TRIM_MATCHED_RESC_INFO|TRIM_UNMATCHED_OBJ_INFO, &trimmedDataObjInfo);
01282 *destDataObjInfo = *oldDataObjInfoHead;
01283 *oldDataObjInfoHead = trimmedDataObjInfo;
01284 } else {
01285 char* destRescHier = getValByKey(condInput, DEST_RESC_HIER_STR_KW);
01286 *destDataObjInfo = chkCopyInResc (*oldDataObjInfoHead, *destRescGrpInfo, destRescHier);
01287 if (*destDataObjInfo != NULL) {
01288
01289 matchAndTrimRescGrp (oldDataObjInfoHead, destRescGrpInfo,
01290 TRIM_MATCHED_RESC_INFO, NULL);
01291 if (*destRescGrpInfo != NULL) {
01292
01293 *destDataObjInfo = NULL;
01294 } else {
01295 dequeDataObjInfo (oldDataObjInfoHead, *destDataObjInfo);
01296 }
01297 }
01298 }
01299 return (NO_GOOD_COPY);
01300 }
01301
01302 int
01303 resolveInfoForPhymv (dataObjInfo_t **dataObjInfoHead,
01304 dataObjInfo_t **oldDataObjInfoHead,
01305 rescGrpInfo_t **destRescGrpInfo,
01306 keyValPair_t *condInput,
01307 int multiCopyFlag ) {
01308 int status;
01309 dataObjInfo_t *matchedDataObjInfo = NULL;
01310 dataObjInfo_t *matchedOldDataObjInfo = NULL;
01311
01312
01313 status = matchDataObjInfoByCondInput (dataObjInfoHead, oldDataObjInfoHead,
01314 condInput, &matchedDataObjInfo, &matchedOldDataObjInfo);
01315
01316 if (status < 0) {
01317 return status;
01318 }
01319
01320 if (matchedDataObjInfo != NULL) {
01321
01322
01323 *oldDataObjInfoHead = *dataObjInfoHead;
01324 *dataObjInfoHead = matchedDataObjInfo;
01325 }
01326
01327 if (multiCopyFlag) {
01328 matchAndTrimRescGrp (dataObjInfoHead, destRescGrpInfo,
01329 REQUE_MATCHED_RESC_INFO, NULL);
01330 matchAndTrimRescGrp (oldDataObjInfoHead, destRescGrpInfo,
01331 REQUE_MATCHED_RESC_INFO, NULL);
01332 } else {
01333 matchAndTrimRescGrp (dataObjInfoHead, destRescGrpInfo,
01334 TRIM_MATCHED_RESC_INFO|TRIM_MATCHED_OBJ_INFO, NULL);
01335 matchAndTrimRescGrp (oldDataObjInfoHead, destRescGrpInfo,
01336 TRIM_MATCHED_RESC_INFO, NULL);
01337 }
01338
01339 if (*destRescGrpInfo == NULL) {
01340 if (*dataObjInfoHead == NULL) {
01341 return (CAT_NO_ROWS_FOUND);
01342 } else {
01343
01344 rodsLog (LOG_ERROR,
01345 "resolveInfoForPhymv: %s already have copy in the resc",
01346 (*dataObjInfoHead)->objPath);
01347 return (SYS_COPY_ALREADY_IN_RESC);
01348 }
01349 } else {
01350 return (0);
01351 }
01352 }
01353
01354
01355
01356
01357
01358
01359
01360
01361 int matchDataObjInfoByCondInput (dataObjInfo_t **dataObjInfoHead,
01362 dataObjInfo_t **oldDataObjInfoHead, keyValPair_t *condInput,
01363 dataObjInfo_t **matchedDataObjInfo, dataObjInfo_t **matchedOldDataObjInfo)
01364
01365 {
01366
01367 int replNumCond;
01368 int replNum;
01369 int rescCond;
01370 bool destHierCond = false;
01371 char *tmpStr, *rescName;
01372 char* rescHier = NULL;
01373 char* destRescHier = NULL;
01374 dataObjInfo_t *prevDataObjInfo, *nextDataObjInfo, *tmpDataObjInfo;
01375
01376 if (dataObjInfoHead == NULL || *dataObjInfoHead == NULL ||
01377 oldDataObjInfoHead == NULL || matchedDataObjInfo == NULL ||
01378 matchedOldDataObjInfo == NULL) {
01379 rodsLog (LOG_ERROR,
01380 "requeDataObjInfoByCondInput: NULL dataObjInfo input");
01381 return (USER__NULL_INPUT_ERR);
01382 }
01383
01384 if ((tmpStr = getValByKey (condInput, REPL_NUM_KW)) != NULL) {
01385 replNum = atoi (tmpStr);
01386 replNumCond = 1;
01387 } else {
01388 replNumCond = 0;
01389 }
01390
01391 destRescHier = getValByKey(condInput, DEST_RESC_HIER_STR_KW);
01392 rescHier = getValByKey(condInput, RESC_HIER_STR_KW);
01393 if(destRescHier != NULL && rescHier != NULL) {
01394 destHierCond = true;
01395 }
01396
01397
01398 if (!destHierCond && (rescName = getValByKey (condInput, RESC_NAME_KW)) != NULL) {
01399 rescCond = 1;
01400 } else {
01401 rescCond = 0;
01402 }
01403
01404 if (replNumCond + rescCond == 0 && !destHierCond) {
01405 return (0);
01406 }
01407
01408 *matchedDataObjInfo = NULL;
01409 *matchedOldDataObjInfo = NULL;
01410
01411 tmpDataObjInfo = *dataObjInfoHead;
01412 prevDataObjInfo = NULL;
01413 while (tmpDataObjInfo != NULL) {
01414 nextDataObjInfo = tmpDataObjInfo->next;
01415 if (replNumCond == 1 && replNum == tmpDataObjInfo->replNum) {
01416 if (prevDataObjInfo != NULL) {
01417 prevDataObjInfo->next = tmpDataObjInfo->next;
01418 } else {
01419 *dataObjInfoHead = (*dataObjInfoHead)->next;
01420 }
01421 queDataObjInfo (matchedDataObjInfo, tmpDataObjInfo, 1, 0);
01422 } else if(destHierCond &&
01423 (strcmp(rescHier, tmpDataObjInfo->rescHier) == 0 ||
01424 strcmp(destRescHier, tmpDataObjInfo->rescHier) == 0)) {
01425 if (prevDataObjInfo != NULL) {
01426 prevDataObjInfo->next = tmpDataObjInfo->next;
01427 } else {
01428 *dataObjInfoHead = (*dataObjInfoHead)->next;
01429 }
01430 queDataObjInfo (matchedDataObjInfo, tmpDataObjInfo, 1, 0);
01431 } else if (rescCond == 1 &&
01432 (strcmp (rescName, tmpDataObjInfo->rescGroupName) == 0 ||
01433 strcmp (rescName, tmpDataObjInfo->rescName) == 0)) {
01434 if (prevDataObjInfo != NULL) {
01435 prevDataObjInfo->next = tmpDataObjInfo->next;
01436 } else {
01437 *dataObjInfoHead = (*dataObjInfoHead)->next;
01438 }
01439
01440 queDataObjInfo (matchedDataObjInfo, tmpDataObjInfo, 1, 0);
01441 } else {
01442 prevDataObjInfo = tmpDataObjInfo;
01443 }
01444 tmpDataObjInfo = nextDataObjInfo;
01445 }
01446
01447 tmpDataObjInfo = *oldDataObjInfoHead;
01448 prevDataObjInfo = NULL;
01449 while (tmpDataObjInfo != NULL) {
01450 nextDataObjInfo = tmpDataObjInfo->next;
01451 if (replNumCond == 1 && replNum == tmpDataObjInfo->replNum) {
01452 if (prevDataObjInfo != NULL) {
01453 prevDataObjInfo->next = tmpDataObjInfo->next;
01454 } else {
01455 *oldDataObjInfoHead = (*oldDataObjInfoHead)->next;
01456 }
01457 queDataObjInfo (matchedOldDataObjInfo, tmpDataObjInfo, 1, 0);
01458 } else if(destHierCond &&
01459 (strcmp(rescHier, tmpDataObjInfo->rescHier) == 0 ||
01460 strcmp(destRescHier, tmpDataObjInfo->rescHier) == 0)) {
01461 if (prevDataObjInfo != NULL) {
01462 prevDataObjInfo->next = tmpDataObjInfo->next;
01463 } else {
01464 *oldDataObjInfoHead = (*oldDataObjInfoHead)->next;
01465 }
01466 queDataObjInfo (matchedDataObjInfo, tmpDataObjInfo, 1, 0);
01467 } else if (rescCond == 1 &&
01468 (strcmp (rescName, tmpDataObjInfo->rescGroupName) == 0 ||
01469 strcmp (rescName, tmpDataObjInfo->rescName)) == 0) {
01470 if (prevDataObjInfo != NULL) {
01471 prevDataObjInfo->next = tmpDataObjInfo->next;
01472 } else {
01473 *oldDataObjInfoHead = (*oldDataObjInfoHead)->next;
01474 }
01475 queDataObjInfo (matchedOldDataObjInfo, tmpDataObjInfo, 1, 0);
01476 } else {
01477 prevDataObjInfo = tmpDataObjInfo;
01478 }
01479 tmpDataObjInfo = nextDataObjInfo;
01480 }
01481
01482 if (*matchedDataObjInfo == NULL && *matchedOldDataObjInfo == NULL) {
01483 return (CAT_NO_ROWS_FOUND);
01484 } else {
01485 return (replNumCond + rescCond);
01486 }
01487 }
01488
01489 int
01490 resolveInfoForTrim (dataObjInfo_t **dataObjInfoHead,
01491 keyValPair_t *condInput)
01492 {
01493 int i, status;
01494 dataObjInfo_t *matchedDataObjInfo = NULL;
01495 dataObjInfo_t *matchedOldDataObjInfo = NULL;
01496 dataObjInfo_t *oldDataObjInfoHead = NULL;
01497 dataObjInfo_t *tmpDataObjInfo, *prevDataObjInfo;
01498 int matchedInfoCnt, unmatchedInfoCnt, matchedOldInfoCnt,
01499 unmatchedOldInfoCnt;
01500 int minCnt;
01501 char *tmpStr;
01502 int condFlag;
01503 int toTrim;
01504
01505 sortObjInfoForRepl (dataObjInfoHead, &oldDataObjInfoHead, 0);
01506
01507 status = matchDataObjInfoByCondInput (dataObjInfoHead, &oldDataObjInfoHead,
01508 condInput, &matchedDataObjInfo, &matchedOldDataObjInfo);
01509
01510 if (status < 0) {
01511 freeAllDataObjInfo (*dataObjInfoHead);
01512 freeAllDataObjInfo (oldDataObjInfoHead);
01513 *dataObjInfoHead = NULL;
01514 if (status == CAT_NO_ROWS_FOUND) {
01515 return 0;
01516 } else {
01517 rodsLog(LOG_NOTICE, "%s - Failed during matching of data objects.", __FUNCTION__);
01518 return status;
01519 }
01520 }
01521 condFlag = status;
01522
01523 if (matchedDataObjInfo == NULL && matchedOldDataObjInfo == NULL) {
01524 if (dataObjInfoHead != NULL && condFlag == 0) {
01525
01526
01527 matchedOldDataObjInfo = oldDataObjInfoHead;
01528 oldDataObjInfoHead = NULL;
01529
01530 matchedDataObjInfo = *dataObjInfoHead;
01531 *dataObjInfoHead = NULL;
01532 } else {
01533
01534 if (dataObjInfoHead != NULL ) {
01535 freeAllDataObjInfo (*dataObjInfoHead);
01536 *dataObjInfoHead = NULL;
01537 }
01538 freeAllDataObjInfo (oldDataObjInfoHead);
01539 return (0);
01540 }
01541 }
01542
01543 matchedInfoCnt = getDataObjInfoCnt (matchedDataObjInfo);
01544 unmatchedInfoCnt = getDataObjInfoCnt (*dataObjInfoHead);
01545 unmatchedOldInfoCnt = getDataObjInfoCnt (oldDataObjInfoHead);
01546
01547
01548
01549 freeAllDataObjInfo (*dataObjInfoHead);
01550 freeAllDataObjInfo (oldDataObjInfoHead);
01551 *dataObjInfoHead = oldDataObjInfoHead = NULL;
01552
01553 if ((tmpStr = getValByKey (condInput, COPIES_KW)) != NULL) {
01554 minCnt = atoi (tmpStr);
01555 if (minCnt <= 0) {
01556 minCnt = DEF_MIN_COPY_CNT;
01557 }
01558 } else {
01559 minCnt = DEF_MIN_COPY_CNT;
01560 }
01561
01562 toTrim = unmatchedInfoCnt + matchedInfoCnt - minCnt;
01563
01564 if (toTrim > matchedInfoCnt) {
01565 toTrim = matchedInfoCnt;
01566 }
01567
01568 if (toTrim >= 0) {
01569
01570 *dataObjInfoHead = matchedOldDataObjInfo;
01571
01572
01573
01574 for (i = 0; i < matchedInfoCnt - toTrim; i++) {
01575 prevDataObjInfo = NULL;
01576 tmpDataObjInfo = matchedDataObjInfo;
01577 while (tmpDataObjInfo != NULL) {
01578 if (tmpDataObjInfo->next == NULL) {
01579 if (prevDataObjInfo == NULL) {
01580
01581 matchedDataObjInfo = NULL;
01582 } else {
01583 prevDataObjInfo->next = NULL;
01584 }
01585 freeDataObjInfo (tmpDataObjInfo);
01586 break;
01587 }
01588 prevDataObjInfo = tmpDataObjInfo;
01589 tmpDataObjInfo = tmpDataObjInfo->next;
01590 }
01591 }
01592 queDataObjInfo (dataObjInfoHead, matchedDataObjInfo, 0, 1);
01593 } else {
01594
01595 freeAllDataObjInfo (matchedDataObjInfo);
01596 matchedOldInfoCnt = getDataObjInfoCnt (matchedOldDataObjInfo);
01597 toTrim = matchedOldInfoCnt + unmatchedOldInfoCnt + toTrim;
01598 if (toTrim > matchedOldInfoCnt)
01599 toTrim = matchedOldInfoCnt;
01600
01601 if (toTrim <= 0) {
01602 freeAllDataObjInfo (matchedOldDataObjInfo);
01603 } else {
01604
01605
01606 for (i = 0; i < matchedOldInfoCnt - toTrim; i++) {
01607 prevDataObjInfo = NULL;
01608 tmpDataObjInfo = matchedOldDataObjInfo;
01609 while (tmpDataObjInfo != NULL) {
01610 if (tmpDataObjInfo->next == NULL) {
01611 if (prevDataObjInfo == NULL) {
01612 matchedOldDataObjInfo = NULL;
01613 } else {
01614 prevDataObjInfo->next = NULL;
01615 }
01616 freeDataObjInfo (tmpDataObjInfo);
01617 break;
01618 }
01619 prevDataObjInfo = tmpDataObjInfo;
01620 tmpDataObjInfo = tmpDataObjInfo->next;
01621 }
01622 }
01623 queDataObjInfo (dataObjInfoHead, matchedOldDataObjInfo, 0, 1);
01624 }
01625 }
01626 return (0);
01627 }
01628
01629 int
01630 requeDataObjInfoByDestResc (dataObjInfo_t **dataObjInfoHead,
01631 keyValPair_t *condInput, int writeFlag, int topFlag)
01632 {
01633 char *rescName;
01634 int status = -1;
01635 if ((rescName = getValByKey (condInput, DEST_RESC_NAME_KW)) != NULL ||
01636 (rescName = getValByKey (condInput, BACKUP_RESC_NAME_KW)) != NULL ||
01637 (rescName = getValByKey (condInput, DEF_RESC_NAME_KW)) != NULL) {
01638 status = requeDataObjInfoByResc (dataObjInfoHead, rescName,
01639 writeFlag, topFlag);
01640 }
01641 return (status);
01642 }
01643 #if 0 // JMC - UNUSED
01644 int
01645 requeDataObjInfoBySrcResc (dataObjInfo_t **dataObjInfoHead,
01646 keyValPair_t *condInput, int writeFlag, int topFlag)
01647 {
01648 char *rescName;
01649
01650 if ((rescName = getValByKey (condInput, RESC_NAME_KW)) != NULL) {
01651 requeDataObjInfoByResc (dataObjInfoHead, rescName, writeFlag, topFlag);
01652 }
01653 return (0);
01654 }
01655 #endif // JMC - UNUSED
01656 int
01657 getDataObjInfoIncSpecColl (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
01658 dataObjInfo_t **dataObjInfo)
01659 {
01660 int status, writeFlag;
01661 specCollPerm_t specCollPerm;
01662 writeFlag = getWriteFlag (dataObjInp->openFlags);
01663 if (writeFlag > 0) {
01664 specCollPerm = WRITE_COLL_PERM;
01665 if (rsComm->clientUser.authInfo.authFlag <= PUBLIC_USER_AUTH) {
01666 rodsLog (LOG_NOTICE,
01667 "getDataObjInfoIncSpecColl:open for write not allowed for user %s",
01668 rsComm->clientUser.userName);
01669 return (SYS_NO_API_PRIV);
01670 }
01671 } else {
01672 specCollPerm = READ_COLL_PERM;
01673 }
01674
01675 if (dataObjInp->specColl != NULL &&
01676 dataObjInp->specColl->collClass != NO_SPEC_COLL &&
01677 dataObjInp->specColl->collClass != LINKED_COLL) {
01678
01679 status = resolvePathInSpecColl (rsComm, dataObjInp->objPath,
01680 specCollPerm, 0, dataObjInfo);
01681 if (status == SYS_SPEC_COLL_OBJ_NOT_EXIST &&
01682 dataObjInfo != NULL) {
01683 freeDataObjInfo (*dataObjInfo);
01684 dataObjInfo = NULL;
01685 }
01686 } else if ((status = resolvePathInSpecColl (rsComm, dataObjInp->objPath,
01687 specCollPerm, 1, dataObjInfo)) >= 0) {
01688
01689 } else if (getValByKey (&dataObjInp->condInput,
01690 IRODS_ADMIN_RMTRASH_KW) != NULL &&
01691 rsComm->proxyUser.authInfo.authFlag == LOCAL_PRIV_USER_AUTH) {
01692 status = getDataObjInfo (rsComm, dataObjInp, dataObjInfo,
01693 NULL, 0);
01694 } else if (writeFlag > 0 && dataObjInp->oprType != REPLICATE_OPR) {
01695 status = getDataObjInfo (rsComm, dataObjInp, dataObjInfo,
01696 ACCESS_DELETE_OBJECT, 0);
01697 } else {
01698 status = getDataObjInfo (rsComm, dataObjInp, dataObjInfo,
01699 ACCESS_READ_OBJECT, 0);
01700 }
01701
01702 if (status < 0 && dataObjInp->specColl == NULL) {
01703 int status2;
01704 status2 = resolvePathInSpecColl (rsComm, dataObjInp->objPath,
01705 specCollPerm, 0, dataObjInfo);
01706 if (status2 < 0) {
01707 if (status2 == SYS_SPEC_COLL_OBJ_NOT_EXIST &&
01708 dataObjInfo != NULL) {
01709 freeDataObjInfo (*dataObjInfo);
01710 *dataObjInfo = NULL;
01711 }
01712 }
01713 if (status2 >= 0) status = 0;
01714 }
01715 if (status >= 0) {
01716 if ((*dataObjInfo)->specColl != NULL) {
01717 if ((*dataObjInfo)->specColl->collClass == LINKED_COLL) {
01718
01719 rstrcpy (dataObjInp->objPath, (*dataObjInfo)->objPath,
01720 MAX_NAME_LEN);
01721 free ((*dataObjInfo)->specColl);
01722 (*dataObjInfo)->specColl = NULL;
01723 } else if (getStructFileType ((*dataObjInfo)->specColl) >= 0) {
01724 dataObjInp->numThreads = NO_THREADING;
01725 }
01726 }
01727 }
01728 return (status);
01729 }
01730
01731 int regNewObjSize (rsComm_t *rsComm, char *objPath, int replNum,
01732 rodsLong_t newSize)
01733 {
01734 dataObjInfo_t dataObjInfo;
01735 keyValPair_t regParam;
01736 modDataObjMeta_t modDataObjMetaInp;
01737 char tmpStr[MAX_NAME_LEN];
01738 int status;
01739
01740 if (objPath == NULL) return USER__NULL_INPUT_ERR;
01741
01742 memset (&dataObjInfo, 0, sizeof (dataObjInfo));
01743 memset (®Param, 0, sizeof (regParam));
01744 memset (&modDataObjMetaInp, 0, sizeof (modDataObjMetaInp));
01745
01746 rstrcpy (dataObjInfo.objPath, objPath, MAX_NAME_LEN);
01747 dataObjInfo.replNum = replNum;
01748 snprintf (tmpStr, MAX_NAME_LEN, "%lld", newSize);
01749 addKeyVal (®Param, DATA_SIZE_KW, tmpStr);
01750
01751 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01752 modDataObjMetaInp.regParam = ®Param;
01753 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
01754 if (status < 0) {
01755 rodsLog (LOG_ERROR,
01756 "regNewObjSize: rsModDataObjMeta error for %s, status = %d",
01757 objPath, status);
01758 }
01759
01760 return (status);
01761 }
01762
01763 #if 0 // JMC - legacy resource
01764 int
01765 getCacheDataInfoForRepl (rsComm_t *rsComm, dataObjInfo_t *srcDataObjInfoHead,
01766 dataObjInfo_t *destDataObjInfoHead, dataObjInfo_t *compDataObjInfo,
01767 dataObjInfo_t **outDataObjInfo)
01768 {
01769 char *rescGroupName;
01770 int status;
01771
01772 rescGroupName = compDataObjInfo->rescGroupName;
01773
01774 if (strlen (rescGroupName) == 0) {
01775 rescGrpInfo_t *rescGrpInfo = NULL;
01776 rescGrpInfo_t *tmpRescGrpInfo;
01777
01778
01779 status = getRescGrpOfResc (rsComm, compDataObjInfo->rescInfo,&rescGrpInfo);
01780
01781 if (status < 0) {
01782 rodsLog (LOG_NOTICE,
01783 "getCacheDataInfoForRepl:getRescGrpOfResc err for %s. stat=%d",
01784 compDataObjInfo->rescInfo->rescName, status);
01785 return status;
01786 }
01787 tmpRescGrpInfo = rescGrpInfo;
01788
01789 while (tmpRescGrpInfo != NULL) {
01790 status = getCacheDataInfoInRescGrp (srcDataObjInfoHead,
01791 destDataObjInfoHead, tmpRescGrpInfo->rescGroupName,
01792 compDataObjInfo, outDataObjInfo);
01793 if (status >= 0) {
01794
01795 rstrcpy (compDataObjInfo->rescGroupName,
01796 tmpRescGrpInfo->rescGroupName, NAME_LEN);
01797 rstrcpy ((*outDataObjInfo)->rescGroupName,
01798 tmpRescGrpInfo->rescGroupName, NAME_LEN);
01799 freeAllRescGrpInfo (rescGrpInfo);
01800 return 0;
01801 } else {
01802 status = getNonGrpCacheDataInfoInRescGrp (srcDataObjInfoHead,destDataObjInfoHead, tmpRescGrpInfo,compDataObjInfo, outDataObjInfo);
01803 if (status >= 0) {
01804
01805
01806
01807 if (strlen ((*outDataObjInfo)->rescGroupName) > 0) {
01808 rescInfo_t *myRescInfo = NULL;
01809 if (getRescInGrp( rsComm, compDataObjInfo->rescInfo->rescName,
01810 (*outDataObjInfo)->rescGroupName, &myRescInfo) >= 0) {
01811 rstrcpy (compDataObjInfo->rescGroupName,(*outDataObjInfo)->rescGroupName, NAME_LEN);
01812 freeAllRescGrpInfo (rescGrpInfo);
01813 status = SYS_NO_CACHE_RESC_IN_GRP;
01814 } else {
01815 status = getCacheDataInfoInRescGrp (srcDataObjInfoHead,
01816 destDataObjInfoHead, rescGroupName, compDataObjInfo, outDataObjInfo);
01817 if (status < 0) {
01818 rescGrpInfo_t *tmpRescGrpInfo;
01819
01820 status = resolveRescGrp (rsComm, rescGroupName, &tmpRescGrpInfo);
01821 if (status >= 0) {
01822 status = getNonGrpCacheDataInfoInRescGrp (srcDataObjInfoHead,
01823 destDataObjInfoHead, tmpRescGrpInfo,
01824 compDataObjInfo, outDataObjInfo);
01825 if (status >= 0) {
01826
01827 rstrcpy (compDataObjInfo->rescGroupName,
01828 tmpRescGrpInfo->rescGroupName, NAME_LEN);
01829 rstrcpy ((*outDataObjInfo)->rescGroupName,
01830 tmpRescGrpInfo->rescGroupName, NAME_LEN);
01831 }
01832 freeAllRescGrpInfo (tmpRescGrpInfo);
01833 }
01834 }
01835 }
01836 return status;
01837 }
01838
01839
01840
01841
01842 int
01843 getNonGrpCacheDataInfoInRescGrp (dataObjInfo_t *srcDataObjInfoHead,
01844 dataObjInfo_t *destDataObjInfoHead, rescGrpInfo_t *rescGrpInfo,
01845 dataObjInfo_t *compDataObjInfo, dataObjInfo_t **outDataObjInfo)
01846 {
01847
01848 dataObjInfo_t *srcDataObjInfo;
01849 rescGrpInfo_t *tmpRescGrpInfo;
01850
01851 srcDataObjInfo = srcDataObjInfoHead;
01852 while (srcDataObjInfo != NULL) {
01853
01854
01855 tmpRescGrpInfo = rescGrpInfo;
01856 while (tmpRescGrpInfo != NULL) {
01857 if (strcmp (srcDataObjInfo->rescInfo->rescName,
01858 tmpRescGrpInfo->rescInfo->rescName) == 0) {
01859 *outDataObjInfo = srcDataObjInfo;
01860 return 0;
01861 }
01862 tmpRescGrpInfo = tmpRescGrpInfo->next;
01863 }
01864
01865
01866 srcDataObjInfo = srcDataObjInfo->next;
01867 }
01868
01869
01870
01871
01872 srcDataObjInfo = destDataObjInfoHead;
01873 while (srcDataObjInfo != NULL) {
01874 if (srcDataObjInfo == compDataObjInfo) break;
01875
01876
01877 tmpRescGrpInfo = rescGrpInfo;
01878 while (tmpRescGrpInfo != NULL) {
01879 if (strcmp (srcDataObjInfo->rescInfo->rescName,
01880 tmpRescGrpInfo->rescInfo->rescName) == 0) {
01881 *outDataObjInfo = srcDataObjInfo;
01882 return 0;
01883 }
01884 tmpRescGrpInfo = tmpRescGrpInfo->next;
01885 }
01886
01887 srcDataObjInfo = srcDataObjInfo->next;
01888 }
01889 return SYS_NO_CACHE_RESC_IN_GRP;
01890
01891 }
01892
01893 int
01894 getCacheDataInfoInRescGrp (dataObjInfo_t *srcDataObjInfoHead,
01895 dataObjInfo_t *destDataObjInfoHead, char *rescGroupName,
01896 dataObjInfo_t *compDataObjInfo, dataObjInfo_t **outDataObjInfo)
01897 {
01898 dataObjInfo_t *srcDataObjInfo;
01899
01900 srcDataObjInfo = srcDataObjInfoHead;
01901 while (srcDataObjInfo != NULL) {
01902 if (strcmp (srcDataObjInfo->rescGroupName, rescGroupName) == 0) {
01903
01904
01905 *outDataObjInfo = srcDataObjInfo;
01906 return 0;
01907
01908 }
01909
01910 srcDataObjInfo = srcDataObjInfo->next;
01911 }
01912
01913
01914
01915
01916 srcDataObjInfo = destDataObjInfoHead;
01917 while (srcDataObjInfo != NULL) {
01918 if (srcDataObjInfo == compDataObjInfo) break;
01919 if (strcmp (srcDataObjInfo->rescGroupName, rescGroupName) == 0) {
01920
01921
01922 *outDataObjInfo = srcDataObjInfo;
01923 return 0;
01924
01925 }
01926 srcDataObjInfo = srcDataObjInfo->next;
01927 }
01928 return SYS_NO_CACHE_RESC_IN_GRP;
01929 }
01930
01931 int
01932 getDataObjByClass ( dataObjInfo_t *dataObjInfoHead, int rescClass,
01933 dataObjInfo_t **outDataObjInfo) {
01934 if (outDataObjInfo == NULL) return USER__NULL_INPUT_ERR;
01935 *outDataObjInfo = NULL;
01936 while (tmpDataObjInfo != NULL) {
01937
01938 std::string resc_class;
01939 eirods::get_resource_property( tmpDataObjInfo->rescInfo->rescName, "class", resc_class );
01940
01941 for( int i = 0; i < NumRescClass; ++i ) {
01942 if( resc_class == std::string( RescClass[i].className ) &&
01943 RescClass[i].classType == rescClass ) {
01944
01945 *outDataObjInfo = tmpDataObjInfo;
01946 return 0;
01947 }
01948
01949 }
01950
01951 tmpDataObjInfo = tmpDataObjInfo->next;
01952
01953 }
01954 return -1;
01955 }
01956
01957 #endif // JMC - legacy resource
01958