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