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