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