00001
00002
00003
00004
00005
00006
00007
00008
00009 #include <unistd.h>
00010 #include <fcntl.h>
00011 #include "rodsDef.h"
00012 #include "physPath.h"
00013 #include "dataObjOpr.h"
00014 #include "rodsDef.h"
00015 #include "rsGlobalExtern.h"
00016 #include "fileChksum.h"
00017 #include "modDataObjMeta.h"
00018 #include "objMetaOpr.h"
00019 #include "collection.h"
00020 #include "resource.h"
00021 #include "dataObjClose.h"
00022 #include "rcGlobalExtern.h"
00023 #include "reGlobalsExtern.h"
00024 #include "reDefines.h"
00025 #include "reSysDataObjOpr.h"
00026 #include "genQuery.h"
00027 #include "rodsClient.h"
00028
00029 #include <iostream>
00030
00031
00032
00033 #include "eirods_resource_backport.h"
00034 #include "eirods_hierarchy_parser.h"
00035 #include "eirods_stacktrace.h"
00036
00037 int
00038 getFileMode (dataObjInp_t *dataObjInp)
00039 {
00040 int createMode;
00041 int defFileMode;
00042
00043 defFileMode = getDefFileMode ();
00044 if (dataObjInp != NULL &&
00045 (dataObjInp->createMode & 0110) != 0) {
00046 if ((defFileMode & 0070) != 0) {
00047 createMode = defFileMode | 0110;
00048 } else {
00049 createMode = defFileMode | 0100;
00050 }
00051 } else {
00052 createMode = defFileMode;
00053 }
00054
00055 return (createMode);
00056 }
00057
00058 int
00059 getFileFlags (int l1descInx)
00060 {
00061 int flags;
00062
00063 dataObjInp_t *dataObjInp = L1desc[l1descInx].dataObjInp;
00064
00065 if (dataObjInp != NULL) {
00066 flags = dataObjInp->openFlags;
00067 } else {
00068 flags = O_RDONLY;
00069 }
00070
00071 return (flags);
00072 }
00073
00074 int
00075 getFilePathName (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00076 dataObjInp_t *dataObjInp)
00077 {
00078 char *filePath;
00079 vaultPathPolicy_t vaultPathPolicy;
00080 int status;
00081
00082 if (dataObjInp != NULL &&
00083 (filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW)) != NULL
00084 && strlen (filePath) > 0) {
00085 rstrcpy (dataObjInfo->filePath, filePath, MAX_NAME_LEN);
00086 return (0);
00087 }
00088
00089
00090 if (dataObjInp != NULL && dataObjInfo->rescInfo == NULL) {
00091 rodsLog (LOG_ERROR,
00092 "getFilePathName: rescInfo for %s not resolved",
00093 dataObjInp->objPath);
00094 return (SYS_INVALID_RESC_INPUT);
00095 }
00096
00097
00098 int chk_path = 0;
00099 eirods::error err = eirods::get_resource_property< int >(
00100 dataObjInfo->rescInfo->rescName,
00101 eirods::RESOURCE_CHECK_PATH_PERM, chk_path );
00102 if( !err.ok() ) {
00103 eirods::log( PASS( err ) );
00104 }
00105
00106 if( NO_CREATE_PATH == chk_path ) {
00107 *dataObjInfo->filePath = '\0';
00108 return 0;
00109 }
00110
00111 std::string vault_path;
00112 status = getLeafRescPathName(dataObjInfo->rescHier, vault_path);
00113 if(status != 0) {
00114 return status;
00115 }
00116
00117 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
00118 if (status < 0) {
00119 return (status);
00120 }
00121
00122 if (vaultPathPolicy.scheme == GRAFT_PATH_S) {
00123 status = setPathForGraftPathScheme (dataObjInp->objPath,
00124 vault_path.c_str(), vaultPathPolicy.addUserName,
00125 rsComm->clientUser.userName, vaultPathPolicy.trimDirCnt,
00126 dataObjInfo->filePath);
00127 } else {
00128 status = setPathForRandomScheme (dataObjInp->objPath,
00129 vault_path.c_str(), rsComm->clientUser.userName,
00130 dataObjInfo->filePath);
00131 }
00132
00133 if (status < 0) {
00134 return (status);
00135 }
00136
00137 return (status);
00138 }
00139
00140 int
00141 getVaultPathPolicy (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00142 vaultPathPolicy_t *outVaultPathPolicy)
00143 {
00144 ruleExecInfo_t rei;
00145 msParam_t *msParam;
00146 int status;
00147
00148 if (outVaultPathPolicy == NULL || dataObjInfo == NULL || rsComm == NULL) {
00149 rodsLog (LOG_ERROR,
00150 "getVaultPathPolicy: NULL input");
00151 return (SYS_INTERNAL_NULL_INPUT_ERR);
00152 }
00153 initReiWithDataObjInp (&rei, rsComm, NULL);
00154
00155 rei.doi = dataObjInfo;
00156 status = applyRule ("acSetVaultPathPolicy", NULL, &rei, NO_SAVE_REI);
00157 if (status < 0) {
00158 rodsLog (LOG_ERROR,
00159 "getVaultPathPolicy: rule acSetVaultPathPolicy error, status = %d",
00160 status);
00161 return (status);
00162 }
00163
00164 if ((msParam = getMsParamByLabel (&rei.inOutMsParamArray,
00165 VAULT_PATH_POLICY)) == NULL) {
00166
00167 outVaultPathPolicy->scheme = DEF_VAULT_PATH_SCHEME;
00168 outVaultPathPolicy->addUserName = DEF_ADD_USER_FLAG;
00169 outVaultPathPolicy->trimDirCnt = DEF_TRIM_DIR_CNT;
00170 } else {
00171 *outVaultPathPolicy = *((vaultPathPolicy_t *) msParam->inOutStruct);
00172 clearMsParamArray (&rei.inOutMsParamArray, 1);
00173 }
00174
00175 if (outVaultPathPolicy->trimDirCnt > DEF_TRIM_DIR_CNT)
00176 outVaultPathPolicy->trimDirCnt = DEF_TRIM_DIR_CNT;
00177
00178 return (0);
00179 }
00180
00181 int
00182 setPathForRandomScheme (char *objPath, const char *vaultPath, char *userName,
00183 char *outPath)
00184 {
00185 int myRandom;
00186 int dir1, dir2;
00187 char logicalCollName[MAX_NAME_LEN];
00188 char logicalFileName[MAX_NAME_LEN];
00189 int status;
00190
00191 myRandom = random ();
00192 dir1 = myRandom & 0xf;
00193 dir2 = (myRandom >> 4) & 0xf;
00194
00195 status = splitPathByKey(objPath,
00196 logicalCollName, logicalFileName, '/');
00197
00198 if (status < 0) {
00199 rodsLog (LOG_ERROR,
00200 "setPathForRandomScheme: splitPathByKey error for %s, status = %d",
00201 outPath, status);
00202 return (status);
00203 }
00204
00205 snprintf (outPath, MAX_NAME_LEN,
00206 "%s/%s/%d/%d/%s.%d", vaultPath, userName, dir1, dir2,
00207 logicalFileName, (uint) time (NULL));
00208 return (0);
00209 }
00210
00211 int
00212 setPathForGraftPathScheme (char *objPath, const char *vaultPath, int addUserName,
00213 char *userName, int trimDirCnt, char *outPath)
00214 {
00215 int i;
00216 char *objPathPtr, *tmpPtr;
00217 int len;
00218
00219 objPathPtr = objPath + 1;
00220
00221 for (i = 0; i < trimDirCnt; i++) {
00222 tmpPtr = strchr (objPathPtr, '/');
00223 if (tmpPtr == NULL) {
00224 rodsLog (LOG_ERROR,
00225 "setPathForGraftPathScheme: objPath %s too short", objPath);
00226 break;
00227 } else {
00228
00229 objPathPtr = tmpPtr + 1;
00230
00231 if (i == 0 && strncmp (objPathPtr, "trash/", 6) == 0) break;
00232 }
00233 }
00234
00235 if (addUserName > 0 && userName != NULL) {
00236 len = snprintf (outPath, MAX_NAME_LEN,
00237 "%s/%s/%s", vaultPath, userName, objPathPtr);
00238 } else {
00239 len = snprintf (outPath, MAX_NAME_LEN,
00240 "%s/%s", vaultPath, objPathPtr);
00241 }
00242
00243 if (len >= MAX_NAME_LEN) {
00244 rodsLog (LOG_ERROR,
00245 "setPathForGraftPathScheme: filePath %s too long", objPath);
00246 return (USER_STRLEN_TOOLONG);
00247 } else {
00248 return (0);
00249 }
00250 }
00251
00252
00253
00254
00255
00256 int
00257 resolveDupFilePath (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00258 dataObjInp_t *dataObjInp)
00259 {
00260 char tmpStr[NAME_LEN];
00261 char *filePath;
00262
00263 if (getSizeInVault (rsComm, dataObjInfo) == SYS_PATH_IS_NOT_A_FILE) {
00264
00265 return (SYS_PATH_IS_NOT_A_FILE);
00266 }
00267 if (chkAndHandleOrphanFile (rsComm, dataObjInfo->objPath, dataObjInfo->rescHier, dataObjInfo->filePath,
00268 dataObjInfo->rescInfo, dataObjInfo->replStatus) >= 0) {
00269
00270 return 0;
00271 }
00272
00273 if (dataObjInp != NULL) {
00274 filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW);
00275 if (filePath != NULL && strlen (filePath) > 0) {
00276 return -1;
00277 }
00278 }
00279
00280 if (strlen (dataObjInfo->filePath) >= MAX_NAME_LEN - 3) {
00281 return -1;
00282 }
00283
00284 snprintf (tmpStr, NAME_LEN, ".%d", dataObjInfo->replNum);
00285 strcat (dataObjInfo->filePath, tmpStr);
00286
00287 return (0);
00288 }
00289
00290 int
00291 getchkPathPerm (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00292 dataObjInfo_t *dataObjInfo)
00293 {
00294 int chkPathPerm;
00295 char *filePath;
00296 rescInfo_t *rescInfo;
00297 ruleExecInfo_t rei;
00298
00299 if (rsComm->clientUser.authInfo.authFlag == LOCAL_PRIV_USER_AUTH) {
00300 return (NO_CHK_PATH_PERM);
00301 }
00302
00303 if (dataObjInp == NULL || dataObjInfo == NULL) {
00304 return (NO_CHK_PATH_PERM);
00305 }
00306
00307 rescInfo = dataObjInfo->rescInfo;
00308
00309 if ((filePath = getValByKey (&dataObjInp->condInput, FILE_PATH_KW)) != NULL
00310 && strlen (filePath) > 0) {
00311
00312 if (rescInfo == NULL) {
00313 chkPathPerm = NO_CHK_PATH_PERM;
00314 } else {
00315 initReiWithDataObjInp (&rei, rsComm, dataObjInp);
00316 rei.doi = dataObjInfo;
00317
00318
00319 rei.status = DISALLOW_PATH_REG;
00320 applyRule ("acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI);
00321
00322 int chk_path = 0;
00323 eirods::error err = eirods::get_resource_property< int >(
00324 rescInfo->rescName,
00325 eirods::RESOURCE_CHECK_PATH_PERM, chk_path );
00326 if( !err.ok() ) {
00327 eirods::log( PASS( err ) );
00328 }
00329
00330 if( err.ok() && ( rei.status == NO_CHK_PATH_PERM || NO_CHK_PATH_PERM == chk_path ) ) {
00331
00332 chkPathPerm = NO_CHK_PATH_PERM;
00333 } else {
00334 chkPathPerm = rei.status;
00335
00336 }
00337 }
00338 } else {
00339 chkPathPerm = NO_CHK_PATH_PERM;
00340 }
00341 return (chkPathPerm);
00342 }
00343
00344 int
00345 getCopiesFromCond (keyValPair_t *condInput)
00346 {
00347 char *myValue;
00348
00349 myValue = getValByKey (condInput, COPIES_KW);
00350
00351 if (myValue == NULL) {
00352 return (1);
00353 } else if (strcmp (myValue, "all") == 0) {
00354 return (ALL_COPIES);
00355 } else {
00356 return (atoi (myValue));
00357 }
00358 }
00359
00360 int
00361 getWriteFlag (int openFlag)
00362 {
00363 if (openFlag & O_WRONLY || openFlag & O_RDWR) {
00364 return (1);
00365 } else {
00366 return (0);
00367 }
00368 }
00369
00370 rodsLong_t
00371 getSizeInVault (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo)
00372 {
00373 rodsStat_t *myStat = NULL;
00374 int status;
00375 rodsLong_t mysize;
00376
00377 status = l3Stat (rsComm, dataObjInfo, &myStat);
00378
00379 if (status < 0 || NULL == myStat) {
00380 rodsLog (LOG_DEBUG,
00381 "getSizeInVault: l3Stat error for %s. status = %d",
00382 dataObjInfo->filePath, status);
00383 return (status);
00384 } else {
00385 if (myStat->st_mode & S_IFDIR) {
00386 return ((rodsLong_t) SYS_PATH_IS_NOT_A_FILE);
00387 }
00388 mysize = myStat->st_size;
00389 free (myStat);
00390 return (mysize);
00391 }
00392 }
00393
00394 int
00395 _dataObjChksum (
00396 rsComm_t *rsComm,
00397 dataObjInfo_t *inpDataObjInfo,
00398 char **chksumStr)
00399 {
00400 fileChksumInp_t fileChksumInp;
00401 int rescClass = 0;
00402 int status = 0;
00403
00404
00405 dataObjInfo_t *dataObjInfo;
00406 int destL1descInx = -1;
00407
00408 #if 0 // JMC - removing compound resources
00409 if (rescClass == COMPOUND_CL) {
00410 #if 0
00411 return SYS_CANT_CHKSUM_COMP_RESC_DATA;
00412 #else
00413 dataObjInp_t dataObjInp;
00414 status = getCacheRescInGrp (rsComm, inpDataObjInfo->rescGroupName,inpDataObjInfo->rescInfo, &cacheResc);
00415 if (status < 0) {
00416 rodsLog (LOG_ERROR,
00417 "_dataObjChksum: getCacheRescInGrp %s failed for %s stat=%d",
00418 inpDataObjInfo->rescGroupName, inpDataObjInfo->objPath, status);
00419 return status;
00420 }
00421
00422 memset (&dataObjInp, 0, sizeof (dataObjInp_t));
00423 snprintf (dataObjInp.objPath, MAX_NAME_LEN, "%s.%-d",
00424 inpDataObjInfo->objPath, (int) random());
00425 addKeyVal (&dataObjInp.condInput, DEST_RESC_NAME_KW,
00426 cacheResc->rescName);
00427 addKeyVal (&dataObjInp.condInput, NO_OPEN_FLAG_KW, "");
00428 destL1descInx = _rsDataObjCreate (rsComm, &dataObjInp);
00429 clearKeyVal (&dataObjInp.condInput);
00430 if (destL1descInx < 0) {
00431 rodsLogError (LOG_ERROR, destL1descInx,
00432 "_dataObjChksum: _rsDataObjCreate failed for %s",
00433 inpDataObjInfo->objPath);
00434 return destL1descInx;
00435 }
00436 dataObjInfo = L1desc[destL1descInx].dataObjInfo;
00437 rescInfo = cacheResc;
00438 status = _l3FileStage (rsComm, inpDataObjInfo, dataObjInfo,
00439 getFileMode (NULL));
00440 if (status < 0) {
00441 rodsLogError (LOG_ERROR, status,
00442 "_dataObjChksum: _l3FileStage failed for %s",
00443 dataObjInfo->objPath);
00444 return destL1descInx;
00445 }
00446 #endif
00447 } else if (rescClass == BUNDLE_CL) {
00448 return SYS_CANT_CHKSUM_BUNDLED_DATA;
00449 } else
00450 #endif // JMC
00451
00452 if (rescClass == BUNDLE_CL) {
00453 return SYS_CANT_CHKSUM_BUNDLED_DATA;
00454 } else {
00455 dataObjInfo = inpDataObjInfo;
00456 }
00457
00458
00459 int category = FILE_CAT;
00460
00461 std::string location;
00462 eirods::error ret;
00463
00464 switch( category ) {
00465 case FILE_CAT:
00466
00467
00468 ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00469 if( !ret.ok() ) {
00470 eirods::log( PASSMSG( "_dataObjChksum - failed in get_loc_for_hier_string", ret ) );
00471 return -1;
00472 }
00473
00474 memset (&fileChksumInp, 0, sizeof (fileChksumInp));
00475 fileChksumInp.fileType = static_cast< fileDriverType_t >( -1 );
00476 rstrcpy (fileChksumInp.addr.hostAddr, location.c_str(),NAME_LEN);
00477 rstrcpy (fileChksumInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00478 rstrcpy (fileChksumInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00479 rstrcpy (fileChksumInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00480 rstrcpy (fileChksumInp.in_pdmo, dataObjInfo->in_pdmo, MAX_NAME_LEN);
00481 status = rsFileChksum (rsComm, &fileChksumInp, chksumStr);
00482 if(status == EIRODS_DIRECT_ARCHIVE_ACCESS) {
00483 std::stringstream msg;
00484 msg << "Data object: \"";
00485 msg << dataObjInfo->filePath;
00486 msg << "\" is located in an archive resource. Ignoring its checksum.";
00487 eirods::log(LOG_NOTICE, msg.str());
00488
00489 }
00490 break;
00491 default:
00492 rodsLog (LOG_NOTICE,
00493 "_dataObjChksum: rescCat type %d is not recognized", category );
00494 status = SYS_INVALID_RESC_TYPE;
00495 break;
00496 }
00497
00498
00499 if (destL1descInx >= 0) {
00500 l3Unlink (rsComm, L1desc[destL1descInx].dataObjInfo);
00501 freeL1desc (destL1descInx);
00502 }
00503
00504 return (status);
00505 }
00506
00507 int
00508 dataObjChksumAndReg (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo,
00509 char **chksumStr)
00510 {
00511 keyValPair_t regParam;
00512 modDataObjMeta_t modDataObjMetaInp;
00513 int status;
00514
00515 status = _dataObjChksum (rsComm, dataObjInfo, chksumStr);
00516 if (status < 0) {
00517 rodsLog (LOG_NOTICE,
00518 "dataObjChksumAndReg: _dataObjChksum error for %s, status = %d",
00519 dataObjInfo->objPath, status);
00520 return (status);
00521 }
00522
00523
00524 memset (®Param, 0, sizeof (regParam));
00525 addKeyVal (®Param, CHKSUM_KW, *chksumStr);
00526
00527
00528 addKeyVal(®Param, IN_PDMO_KW, dataObjInfo->rescHier);
00529
00530 modDataObjMetaInp.dataObjInfo = dataObjInfo;
00531 modDataObjMetaInp.regParam = ®Param;
00532
00533 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00534
00535 clearKeyVal (®Param);
00536
00537 if (status < 0) {
00538 rodsLog (LOG_NOTICE,
00539 "dataObjChksumAndReg: rsModDataObjMeta error for %s, status = %d",
00540 dataObjInfo->objPath, status);
00541
00542 }
00543
00544 return (0);
00545 }
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556 int
00557 chkAndHandleOrphanFile (rsComm_t *rsComm, char* objPath, char* rescHier, char *filePath, rescInfo_t *rescInfo,
00558 int replStatus)
00559 {
00560
00561 fileRenameInp_t fileRenameInp;
00562 int status;
00563 dataObjInfo_t myDataObjInfo;
00564
00565 int category = FILE_CAT;
00566
00567 if( FILE_CAT != category ) {
00568
00569 return (-1);
00570 }
00571
00572 if (strlen (filePath) + 17 >= MAX_NAME_LEN) {
00573
00574 return (-1);
00575 }
00576
00577
00578
00579 memset (&myDataObjInfo, 0, sizeof (myDataObjInfo));
00580 memset (&fileRenameInp, 0, sizeof (fileRenameInp));
00581 if ((status = chkOrphanFile (rsComm, filePath, rescInfo->rescName, &myDataObjInfo)) == 0) {
00582 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00583 rstrcpy (fileRenameInp.rescHier, rescHier, MAX_NAME_LEN);
00584 rstrcpy(fileRenameInp.objPath, objPath, MAX_NAME_LEN);
00585
00586
00587 if (replStatus > OLD_COPY || isTrashPath (myDataObjInfo.objPath)) {
00588 modDataObjMeta_t modDataObjMetaInp;
00589 keyValPair_t regParam;
00590
00591
00592
00593 status = renameFilePathToNewDir (rsComm, REPL_DIR, &fileRenameInp,
00594 rescInfo, 1);
00595 if (status < 0) {
00596 char* sys_error;
00597 char* rods_error = rodsErrorName(status, &sys_error);
00598 rodsLog(LOG_ERROR, "%s:%d renameFilePathToNewDir failed for file: %s - status = %d %s %s",
00599 __FUNCTION__, __LINE__, filePath, status, rods_error, sys_error);
00600 return (status);
00601 }
00602
00603 memset (®Param, 0, sizeof (regParam));
00604 addKeyVal (®Param, FILE_PATH_KW, fileRenameInp.newFileName);
00605 modDataObjMetaInp.dataObjInfo = &myDataObjInfo;
00606 modDataObjMetaInp.regParam = ®Param;
00607 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00608 clearKeyVal (®Param);
00609 if (status < 0) {
00610 rodsLog (LOG_ERROR,
00611 "%s:%d rsModDataObjMeta of %s error. stat = %d",
00612 __FUNCTION__, __LINE__, fileRenameInp.newFileName, status);
00613
00614 rstrcpy (fileRenameInp.oldFileName, fileRenameInp.newFileName,
00615 MAX_NAME_LEN);
00616 rstrcpy (fileRenameInp.newFileName, filePath, MAX_NAME_LEN);
00617 rstrcpy(fileRenameInp.rescHier, myDataObjInfo.rescHier, MAX_NAME_LEN);
00618 status = rsFileRename (rsComm, &fileRenameInp);
00619
00620 if (status < 0) {
00621 rodsLog (LOG_ERROR,
00622 "%s:%d rsFileRename %s failed, status = %d",
00623 __FUNCTION__, __LINE__, fileRenameInp.oldFileName, status);
00624 return (status);
00625 }
00626
00627 return (-1);
00628 } else {
00629 return (0);
00630 }
00631 } else {
00632
00633
00634 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00635 status = renameFilePathToNewDir (rsComm, REPL_DIR, &fileRenameInp,
00636 rescInfo, 0);
00637 if (status >= 0) {
00638 rstrcpy (filePath, fileRenameInp.newFileName, MAX_NAME_LEN);
00639 return (0);
00640 } else {
00641 char* sys_error;
00642 char* rods_error = rodsErrorName(status, &sys_error);
00643 rodsLog(LOG_ERROR, "%s:%d renameFilePathToNewDir failed for file: %s - status = %d %s %s",
00644 __FUNCTION__, __LINE__, filePath, status, rods_error, sys_error);
00645 return (status);
00646 }
00647 }
00648
00649 } else if (status > 0) {
00650
00651 rstrcpy (fileRenameInp.oldFileName, filePath, MAX_NAME_LEN);
00652 rstrcpy (fileRenameInp.rescHier, rescHier, MAX_NAME_LEN);
00653 rstrcpy (fileRenameInp.objPath, objPath, MAX_NAME_LEN);
00654 status = renameFilePathToNewDir (rsComm, ORPHAN_DIR, &fileRenameInp,
00655 rescInfo, 1);
00656 if (status >= 0) {
00657 return (1);
00658 } else {
00659 char* sys_error;
00660 char* rods_error = rodsErrorName(status, &sys_error);
00661 rodsLog(LOG_ERROR, "%s:%d renameFilePathToNewDir failed for file: %s - status = %d %s %s",
00662 __FUNCTION__, __LINE__, filePath, status, rods_error, sys_error);
00663 return (status);
00664 }
00665 } else {
00666
00667 rodsLog(LOG_ERROR, "%s:%d chkOrphanFile failed for file: %s",
00668 __FUNCTION__, __LINE__, filePath);
00669 return (status);
00670 }
00671 }
00672
00673 int
00674 renameFilePathToNewDir (rsComm_t *rsComm, char *newDir,
00675 fileRenameInp_t *fileRenameInp, rescInfo_t *rescInfo, int renameFlag)
00676 {
00677 int len, status;
00678 char *oldPtr, *newPtr;
00679 char *filePath = fileRenameInp->oldFileName;
00680
00681
00682
00683 std::string location;
00684 eirods::error ret = eirods::get_loc_for_hier_string( fileRenameInp->rescHier, location );
00685 if( !ret.ok() ) {
00686 eirods::log( PASSMSG( "renameFilePathToNewDir - failed in get_loc_for_hier_string", ret ) );
00687 return -1;
00688 }
00689
00690 rstrcpy (fileRenameInp->addr.hostAddr, location.c_str(), NAME_LEN);
00691
00692 std::string vault_path;
00693 ret = eirods::get_vault_path_for_hier_string(fileRenameInp->rescHier, vault_path);
00694 if(!ret.ok()) {
00695 std::stringstream msg;
00696 msg << __FUNCTION__;
00697 msg << " - Unable to determine vault path from resource hierarch: \"";
00698 msg << fileRenameInp->rescHier;
00699 msg << "\"";
00700 eirods::error result = PASSMSG(msg.str(), ret);
00701 eirods::log(result);
00702 return result.code();
00703 }
00704
00705 len = vault_path.size();
00706
00707 if (vault_path.empty()) {
00708 std::stringstream msg;
00709 msg << __FUNCTION__;
00710 msg << " - Vault path is empty.";
00711 eirods::error result = ERROR(RESCVAULTPATH_EMPTY_IN_STRUCT_ERR, msg.str());
00712 eirods::log(result);
00713 return (result.code());
00714 }
00715
00716 std::string file_path = filePath;
00717 if (file_path.find(vault_path) != 0) {
00718
00719 std::stringstream msg;
00720 msg << __FUNCTION__;
00721 msg << " - File: \"";
00722 msg << filePath;
00723 msg << "\" is not in vault: \"";
00724 msg << vault_path;
00725 msg << "\"";
00726 eirods::error result = ERROR(EIRODS_FILE_NOT_IN_VAULT, msg.str());
00727 eirods::log(result);
00728 return result.code();
00729 }
00730
00731 rstrcpy (fileRenameInp->newFileName, vault_path.c_str(), MAX_NAME_LEN);
00732 oldPtr = filePath + len;
00733 newPtr = fileRenameInp->newFileName + len;
00734
00735 snprintf (newPtr, MAX_NAME_LEN - len, "/%s%s.%-d", newDir, oldPtr,
00736 (uint) random());
00737
00738 if (renameFlag > 0) {
00739 status = rsFileRename (rsComm, fileRenameInp);
00740 if (status < 0) {
00741 rodsLog (LOG_NOTICE,
00742 "renameFilePathToNewDir:rsFileRename from %s to %s failed,stat=%d",
00743 filePath, fileRenameInp->newFileName, status);
00744 return status;
00745 } else {
00746 return (0);
00747 }
00748 } else {
00749 return (0);
00750 }
00751 }
00752
00753
00754
00755
00756
00757
00758 int
00759 syncDataObjPhyPath (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00760 dataObjInfo_t *dataObjInfoHead, char *acLCollection)
00761 {
00762 dataObjInfo_t *tmpDataObjInfo;
00763 int status;
00764 int savedStatus = 0;
00765
00766 tmpDataObjInfo = dataObjInfoHead;
00767 while (tmpDataObjInfo != NULL) {
00768 status = syncDataObjPhyPathS( rsComm, dataObjInp, tmpDataObjInfo, acLCollection );
00769
00770 if (status < 0) {
00771 savedStatus = status;
00772 }
00773
00774 tmpDataObjInfo = tmpDataObjInfo->next;
00775 }
00776
00777 return (savedStatus);
00778 }
00779
00780 int
00781 syncDataObjPhyPathS (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00782 dataObjInfo_t *dataObjInfo, char *acLCollection)
00783 {
00784 int status, status1;
00785 fileRenameInp_t fileRenameInp;
00786 rescInfo_t *rescInfo = 0;
00787 modDataObjMeta_t modDataObjMetaInp;
00788 keyValPair_t regParam;
00789 vaultPathPolicy_t vaultPathPolicy;
00790
00791 if (strcmp (dataObjInfo->rescInfo->rescName, BUNDLE_RESC) == 0)
00792 return 0;
00793
00794 int create_path = 0;
00795 eirods::error err = eirods::get_resource_property< int >(
00796 dataObjInfo->rescInfo->rescName,
00797 eirods::RESOURCE_CREATE_PATH, create_path );
00798 if( !err.ok() ) {
00799 eirods::log( PASS( err ) );
00800 }
00801
00802
00803 if( NO_CREATE_PATH == create_path ) {
00804
00805 return 0;
00806 }
00807
00808 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
00809 if (status < 0) {
00810 rodsLog (LOG_NOTICE,
00811 "syncDataObjPhyPathS: getVaultPathPolicy error for %s, status = %d",
00812 dataObjInfo->objPath, status);
00813 } else {
00814 if (vaultPathPolicy.scheme != GRAFT_PATH_S) {
00815
00816 return (0);
00817 }
00818 }
00819
00820 if (isInVault (dataObjInfo) == 0) {
00821
00822 return (0);
00823 }
00824
00825 if (dataObjInfo->rescInfo->rescStatus == INT_RESC_STATUS_DOWN)
00826 return SYS_RESC_IS_DOWN;
00827
00828
00829
00830 std::string location;
00831 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00832 if( !ret.ok() ) {
00833 eirods::log( PASSMSG( "syncDataObjPhyPathS - failed in get_loc_for_hier_string", ret ) );
00834 return -1;
00835 }
00836
00837
00838 memset (&fileRenameInp, 0, sizeof (fileRenameInp));
00839 rstrcpy (fileRenameInp.oldFileName, dataObjInfo->filePath, MAX_NAME_LEN);
00840 rstrcpy (fileRenameInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00841 rstrcpy(fileRenameInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00842 if (dataObjInp == NULL) {
00843 dataObjInp_t myDdataObjInp;
00844 memset (&myDdataObjInp, 0, sizeof (myDdataObjInp));
00845 rstrcpy (myDdataObjInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN);
00846 status = getFilePathName (rsComm, dataObjInfo, &myDdataObjInp);
00847 } else {
00848 status = getFilePathName (rsComm, dataObjInfo, dataObjInp);
00849 }
00850
00851 if (strcmp (fileRenameInp.oldFileName, dataObjInfo->filePath) == 0) {
00852 return (0);
00853 }
00854 rescInfo = dataObjInfo->rescInfo;
00855
00856 if (getSizeInVault (rsComm, dataObjInfo) >= 0) {
00857 if ((status = chkAndHandleOrphanFile (rsComm, dataObjInfo->objPath, dataObjInfo->rescHier,
00858 dataObjInfo->filePath, rescInfo, OLD_COPY)) <= 0) {
00859 rodsLog (LOG_ERROR,
00860 "%s: newFileName %s already in use. Status = %d",
00861 __FUNCTION__, dataObjInfo->filePath, status);
00862 return (SYS_PHY_PATH_INUSE);
00863 }
00864 }
00865
00866
00867
00868 rstrcpy (fileRenameInp.addr.hostAddr, location.c_str(), NAME_LEN);
00869 rstrcpy (fileRenameInp.newFileName, dataObjInfo->filePath,
00870 MAX_NAME_LEN);
00871
00872 status = rsFileRename (rsComm, &fileRenameInp);
00873 if (status < 0) {
00874 rodsLog (LOG_ERROR,
00875 "syncDataObjPhyPath:rsFileRename from %s to %s failed,status=%d",
00876 fileRenameInp.oldFileName, fileRenameInp.newFileName, status);
00877 return (status);
00878 }
00879
00880
00881 memset (®Param, 0, sizeof (regParam));
00882 addKeyVal (®Param, FILE_PATH_KW, fileRenameInp.newFileName);
00883 if (acLCollection != NULL)
00884 addKeyVal (®Param, ACL_COLLECTION_KW, acLCollection);
00885 modDataObjMetaInp.dataObjInfo = dataObjInfo;
00886 modDataObjMetaInp.regParam = ®Param;
00887 status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
00888 clearKeyVal (®Param);
00889 if (status < 0) {
00890 char tmpPath[MAX_NAME_LEN];
00891 rodsLog (LOG_ERROR,
00892 "syncDataObjPhyPath: rsModDataObjMeta of %s error. stat = %d",
00893 fileRenameInp.newFileName, status);
00894
00895 rstrcpy (tmpPath, fileRenameInp.oldFileName, MAX_NAME_LEN);
00896 rstrcpy (fileRenameInp.oldFileName, fileRenameInp.newFileName,
00897 MAX_NAME_LEN);
00898 rstrcpy (fileRenameInp.newFileName, tmpPath, MAX_NAME_LEN);
00899 status1 = rsFileRename (rsComm, &fileRenameInp);
00900
00901 if (status1 < 0) {
00902 rodsLog (LOG_ERROR,
00903 "syncDataObjPhyPath: rollback rename %s failed, status = %d",
00904 fileRenameInp.oldFileName, status1);
00905 }
00906 return (status);
00907 }
00908 return (0);
00909 }
00910
00911
00912
00913
00914
00915
00916 int
00917 syncCollPhyPath (rsComm_t *rsComm, char *collection)
00918 {
00919 int status, i;
00920 int savedStatus = 0;
00921 genQueryOut_t *genQueryOut = NULL;
00922 genQueryInp_t genQueryInp;
00923 int continueInx;
00924
00925 status = rsQueryDataObjInCollReCur (rsComm, collection,
00926 &genQueryInp, &genQueryOut, NULL, 0);
00927
00928 if (status<0 && status != CAT_NO_ROWS_FOUND) {
00929 savedStatus=status;
00930 }
00931
00932 while (status >= 0) {
00933 sqlResult_t *dataIdRes, *subCollRes, *dataNameRes, *replNumRes,
00934 *rescNameRes, *filePathRes, *rescHierRes;
00935 char *tmpDataId, *tmpDataName, *tmpSubColl, *tmpReplNum,
00936 *tmpRescName, *tmpFilePath, *tmpRescHier;
00937 dataObjInfo_t dataObjInfo;
00938
00939 memset (&dataObjInfo, 0, sizeof (dataObjInfo));
00940
00941 if ((dataIdRes = getSqlResultByInx (genQueryOut, COL_D_DATA_ID))
00942 == NULL) {
00943 rodsLog (LOG_ERROR,
00944 "syncCollPhyPath: getSqlResultByInx for COL_COLL_NAME failed");
00945 return (UNMATCHED_KEY_OR_INDEX);
00946 }
00947 if ((subCollRes = getSqlResultByInx (genQueryOut, COL_COLL_NAME))
00948 == NULL) {
00949 rodsLog (LOG_ERROR,
00950 "syncCollPhyPath: getSqlResultByInx for COL_COLL_NAME failed");
00951 return (UNMATCHED_KEY_OR_INDEX);
00952 }
00953 if ((dataNameRes = getSqlResultByInx (genQueryOut, COL_DATA_NAME))
00954 == NULL) {
00955 rodsLog (LOG_ERROR,
00956 "syncCollPhyPath: getSqlResultByInx for COL_DATA_NAME failed");
00957 return (UNMATCHED_KEY_OR_INDEX);
00958 }
00959 if ((replNumRes = getSqlResultByInx (genQueryOut, COL_DATA_REPL_NUM))
00960 == NULL) {
00961 rodsLog (LOG_ERROR,
00962 "syncCollPhyPath:getSqlResultByIn for COL_DATA_REPL_NUM failed");
00963 return (UNMATCHED_KEY_OR_INDEX);
00964 }
00965 if ((rescNameRes = getSqlResultByInx (genQueryOut, COL_D_RESC_NAME))
00966 == NULL) {
00967 rodsLog (LOG_ERROR,
00968 "syncCollPhyPath: getSqlResultByInx for COL_D_RESC_NAME failed");
00969 return (UNMATCHED_KEY_OR_INDEX);
00970 }
00971 if ((filePathRes = getSqlResultByInx (genQueryOut, COL_D_DATA_PATH))
00972 == NULL) {
00973 rodsLog (LOG_ERROR,
00974 "syncCollPhyPath: getSqlResultByInx for COL_D_DATA_PATH failed");
00975 return (UNMATCHED_KEY_OR_INDEX);
00976 }
00977 if ((rescHierRes = getSqlResultByInx (genQueryOut, COL_D_RESC_HIER))
00978 == NULL) {
00979 rodsLog (LOG_ERROR,
00980 "syncCollPhyPath: getSqlResultByInx for COL_D_RESC_HIER failed");
00981 return (UNMATCHED_KEY_OR_INDEX);
00982 }
00983
00984 for (i = 0;i < genQueryOut->rowCnt; i++) {
00985 tmpDataId = &dataIdRes->value[dataIdRes->len * i];
00986 tmpDataName = &dataNameRes->value[dataNameRes->len * i];
00987 tmpSubColl = &subCollRes->value[subCollRes->len * i];
00988 tmpReplNum = &replNumRes->value[replNumRes->len * i];
00989 tmpRescName = &rescNameRes->value[rescNameRes->len * i];
00990 tmpFilePath = &filePathRes->value[filePathRes->len * i];
00991 tmpRescHier = &rescHierRes->value[rescHierRes->len * i];
00992
00993 dataObjInfo.dataId = strtoll (tmpDataId, 0, 0);
00994 snprintf (dataObjInfo.objPath, MAX_NAME_LEN, "%s/%s",
00995 tmpSubColl, tmpDataName);
00996 dataObjInfo.replNum = atoi (tmpReplNum);
00997 rstrcpy (dataObjInfo.rescName, tmpRescName, NAME_LEN);
00998 rstrcpy (dataObjInfo.rescHier, tmpRescHier, MAX_NAME_LEN);
00999
01000
01001
01002
01003
01004
01005
01006 dataObjInfo.rescInfo = new rescInfo_t;
01007 eirods::error err = eirods::get_resc_info( tmpRescName, *dataObjInfo.rescInfo );
01008 if( !err.ok() ) {
01009 std::stringstream msg;
01010 msg << "getDefaultLocalRescInfo - failed to get resource info";
01011 msg << tmpRescName;
01012 eirods::log( PASS( err ) );
01013 }
01014
01015 rstrcpy (dataObjInfo.filePath, tmpFilePath, MAX_NAME_LEN);
01016
01017 status = syncDataObjPhyPathS (rsComm, NULL, &dataObjInfo,
01018 collection);
01019 if (status < 0) {
01020 rodsLog (LOG_ERROR,
01021 "syncCollPhyPath: syncDataObjPhyPathS error for %s,stat=%d",
01022 dataObjInfo.filePath, status);
01023 savedStatus = status;
01024 }
01025
01026 }
01027
01028 continueInx = genQueryOut->continueInx;
01029
01030 freeGenQueryOut (&genQueryOut);
01031
01032 if (continueInx > 0) {
01033
01034 genQueryInp.continueInx = continueInx;
01035 status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
01036 } else {
01037 break;
01038 }
01039 }
01040 clearGenQueryInp (&genQueryInp);
01041
01042 return (savedStatus);
01043 }
01044
01045 int
01046 isInVault (dataObjInfo_t *dataObjInfo)
01047 {
01048 int len;
01049
01050 if (dataObjInfo == NULL || dataObjInfo->rescInfo == NULL) {
01051 return (SYS_INTERNAL_NULL_INPUT_ERR);
01052 }
01053
01054 std::string vault_path;
01055 eirods::error ret = eirods::get_vault_path_for_hier_string(dataObjInfo->rescHier, vault_path);
01056 if(!ret.ok()) {
01057 std::stringstream msg;
01058 msg << __FUNCTION__;
01059 msg << " - Failed to get the vault path for the hierarchy: \"" << dataObjInfo->rescHier << "\"";
01060 ret = PASSMSG(msg.str(), ret);
01061 eirods::log(ret);
01062 return ret.code();
01063 }
01064 len = vault_path.size();
01065
01066 if (strncmp (vault_path.c_str(),
01067 dataObjInfo->filePath, len) == 0) {
01068 return (1);
01069 } else {
01070 return (0);
01071 }
01072 }
01073
01074 #if 0 // JMC - UNUSED
01075
01076
01077
01078
01079 int
01080 initStructFileOprInp (rsComm_t *rsComm,
01081 structFileOprInp_t *structFileOprInp,
01082 structFileExtAndRegInp_t *structFileExtAndRegInp,
01083 dataObjInfo_t *dataObjInfo)
01084 {
01085 int status;
01086 vaultPathPolicy_t vaultPathPolicy;
01087 int addUserNameFlag;
01088
01089 memset (structFileOprInp, 0, sizeof (structFileOprInp_t));
01090 structFileOprInp->specColl = (specColl_t*)malloc (sizeof (specColl_t));
01091 memset (structFileOprInp->specColl, 0, sizeof (specColl_t));
01092 if( strcmp (dataObjInfo->dataType, TAR_DT_STR) == 0 ||
01093 strstr (dataObjInfo->dataType, BUNDLE_STR) == 0) {
01094 structFileOprInp->specColl->type = TAR_STRUCT_FILE_T;
01095 } else if (strcmp (dataObjInfo->dataType, HAAW_DT_STR) == 0) {
01096 structFileOprInp->specColl->type = HAAW_STRUCT_FILE_T;
01097 } else {
01098 rodsLog (LOG_ERROR,
01099 "initStructFileOprInp: objType %s of %s is not a struct file",
01100 dataObjInfo->dataType, dataObjInfo->objPath);
01101 return SYS_OBJ_TYPE_NOT_STRUCT_FILE;
01102 }
01103
01104 rstrcpy (structFileOprInp->specColl->collection,
01105 structFileExtAndRegInp->collection, MAX_NAME_LEN);
01106 rstrcpy (structFileOprInp->specColl->objPath,
01107 structFileExtAndRegInp->objPath, MAX_NAME_LEN);
01108 structFileOprInp->specColl->collClass = STRUCT_FILE_COLL;
01109 rstrcpy (structFileOprInp->specColl->resource, dataObjInfo->rescName,
01110 NAME_LEN);
01111 rstrcpy (structFileOprInp->specColl->phyPath,
01112 dataObjInfo->filePath, MAX_NAME_LEN);
01113
01114 NAME_LEN);
01115
01116 status = getVaultPathPolicy (rsComm, dataObjInfo, &vaultPathPolicy);
01117 if (status < 0) {
01118 return (status);
01119 }
01120
01121 if (vaultPathPolicy.scheme == GRAFT_PATH_S) {
01122 addUserNameFlag = vaultPathPolicy.addUserName;
01123 } else {
01124 rodsLog (LOG_ERROR,
01125 "initStructFileOprInp: vaultPathPolicy.scheme %d for resource %s is not GRAFT_PATH_S",
01126 vaultPathPolicy.scheme, structFileOprInp->specColl->resource);
01127 return SYS_WRONG_RESC_POLICY_FOR_BUN_OPR;
01128 }
01129 status = setPathForGraftPathScheme (structFileExtAndRegInp->collection,
01130 dataObjInfo->rescInfo->rescVaultPath, addUserNameFlag,
01131 rsComm->clientUser.userName, vaultPathPolicy.trimDirCnt,
01132 structFileOprInp->specColl->cacheDir);
01133
01134 return (status);
01135 }
01136 #endif // JMC - UNUSED
01137
01138 int
01139 getDefFileMode ()
01140 {
01141 int defFileMode;
01142 char *modeStr;
01143 if ((modeStr = getenv ("DefFileMode")) != NULL && *modeStr == '0') {
01144 defFileMode = strtol (getenv ("DefFileMode"), 0, 0);
01145 } else {
01146 defFileMode = DEFAULT_FILE_MODE;
01147 }
01148 return defFileMode;
01149 }
01150
01151 int
01152 getDefDirMode ()
01153 {
01154 int defDirMode;
01155 char *modeStr;
01156 if ((modeStr = getenv ("DefDirMode")) != NULL && *modeStr == '0') {
01157 defDirMode = strtol (getenv ("DefDirMode"), 0, 0);
01158 } else {
01159 defDirMode = DEFAULT_DIR_MODE;
01160 }
01161 return defDirMode;
01162 }
01163
01164 int
01165 getLogPathFromPhyPath (char *phyPath, rescInfo_t *rescInfo, char *outLogPath)
01166 {
01167 int len;
01168 char *tmpPtr;
01169 zoneInfo_t *tmpZoneInfo = NULL;
01170 int status;
01171
01172 if (phyPath == NULL || rescInfo == NULL || outLogPath == NULL)
01173 return USER__NULL_INPUT_ERR;
01174
01175 len = strlen (rescInfo->rescVaultPath);
01176 if (strncmp (rescInfo->rescVaultPath, phyPath, len) != 0) return -1;
01177 tmpPtr = phyPath + len;
01178
01179 if (*tmpPtr != '/') return -1;
01180
01181 tmpPtr ++;
01182 status = getLocalZoneInfo (&tmpZoneInfo);
01183 if (status < 0 || NULL == tmpZoneInfo ) return status;
01184
01185 len = strlen (tmpZoneInfo->zoneName);
01186 if (strncmp (tmpZoneInfo->zoneName, tmpPtr, len) == 0 &&
01187 *(tmpPtr + len) == '/') {
01188
01189 tmpPtr += (len + 1);
01190 }
01191
01192 snprintf (outLogPath, MAX_NAME_LEN, "/%s/%s", tmpZoneInfo->zoneName,
01193 tmpPtr);
01194
01195 return 0;
01196 }
01197
01198
01199
01200
01201
01202 int
01203 rsMkOrphanPath (rsComm_t *rsComm, char *objPath, char *orphanPath)
01204 {
01205 int status;
01206 char *tmpStr;
01207 char *orphanPathPtr;
01208 int len;
01209 char parentColl[MAX_NAME_LEN], childName[MAX_NAME_LEN];
01210 collInp_t collCreateInp;
01211
01212 status = splitPathByKey(objPath, parentColl, childName, '/');
01213
01214 if (status < 0) {
01215 rodsLog (LOG_ERROR,
01216 "rsMkOrphanPath: splitPathByKey error for %s, status = %d",
01217 objPath, status);
01218 return (status);
01219 }
01220 orphanPathPtr = orphanPath;
01221 *orphanPathPtr = '/';
01222 orphanPathPtr++;
01223 tmpStr = objPath + 1;
01224
01225 while (*tmpStr != '\0') {
01226 *orphanPathPtr = *tmpStr;
01227 orphanPathPtr ++;
01228 len ++;
01229 if (*tmpStr == '/') {
01230 tmpStr ++;
01231 break;
01232 }
01233 tmpStr ++;
01234 }
01235 len = strlen (rsComm->clientUser.userName) +
01236 strlen (rsComm->clientUser.rodsZone);
01237 snprintf (orphanPathPtr, len + 20, "trash/orphan/%s#%s",
01238 rsComm->clientUser.userName, rsComm->clientUser.rodsZone);
01239
01240 memset (&collCreateInp, 0, sizeof (collCreateInp));
01241 rstrcpy (collCreateInp.collName, orphanPath, MAX_NAME_LEN);
01242 status = rsCollCreate (rsComm, &collCreateInp);
01243
01244 if (status < 0 && status != CAT_NAME_EXISTS_AS_COLLECTION) {
01245 rodsLogError (LOG_ERROR, status,
01246 "rsMkOrphanPath: rsCollCreate error for %s",
01247 orphanPath);
01248 }
01249 orphanPathPtr = orphanPath + strlen (orphanPath);
01250
01251 snprintf (orphanPathPtr, strlen (childName) + 20, "/%s.%-d",
01252 childName, (uint) random());
01253
01254 return 0;
01255 }
01256
01257
01258
01259 int
01260 getDataObjLockPath (char *objPath, char **outLockPath)
01261 {
01262 int i;
01263 char *objPathPtr, *tmpPtr;
01264 char tmpPath[MAX_NAME_LEN];
01265 int c;
01266 int len;
01267
01268 if (objPath == NULL || outLockPath == NULL) return USER__NULL_INPUT_ERR;
01269 objPathPtr = objPath;
01270
01271
01272 for (i = 0; i < 3; i++) {
01273 tmpPtr = strchr (objPathPtr, '/');
01274 if (tmpPtr == NULL) {
01275 break;
01276 } else {
01277
01278 objPathPtr = tmpPtr + 1;
01279 }
01280 }
01281 rstrcpy (tmpPath, objPathPtr, MAX_NAME_LEN);
01282
01283 objPathPtr = tmpPath;
01284
01285 while ((c = *objPathPtr) != '\0') {
01286 if (c == '/')
01287 *objPathPtr = '.';
01288 objPathPtr++;
01289 }
01290
01291 len = strlen (getConfigDir()) + strlen (LOCK_FILE_DIR) +
01292 strlen (tmpPath) + strlen (LOCK_FILE_TRAILER) + 10;
01293 *outLockPath = (char *) malloc (len);
01294
01295 snprintf (*outLockPath, len, "%-s/%-s/%-s.%-s", getConfigDir(),
01296 LOCK_FILE_DIR, tmpPath, LOCK_FILE_TRAILER);
01297
01298 return 0;
01299 }
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309 int
01310 fsDataObjLock (char *objPath, int cmd, int type, int infd)
01311 {
01312 int status;
01313 int myFd;
01314 struct flock myflock;
01315 char *path = NULL;
01316
01317 if (type != F_UNLCK) {
01318 if ((status = getDataObjLockPath (objPath, &path)) < 0) {
01319 rodsLogError (LOG_ERROR, status,
01320 "fsDataObjLock: getDataObjLockPath error for %s", objPath);
01321 return status;
01322 }
01323 myFd = open (path, O_RDWR | O_CREAT, 0644);
01324 if (myFd < 0) {
01325 status = FILE_OPEN_ERR - errno;
01326 rodsLogError (LOG_ERROR, status,
01327 "fsDataObjLock: open error for %s", objPath);
01328 return status;
01329 }
01330 } else {
01331 myFd = infd;
01332 }
01333 #ifndef _WIN32
01334 bzero (&myflock, sizeof (myflock));
01335 myflock.l_type = type;
01336 myflock.l_whence = SEEK_SET;
01337 status = fcntl (myFd, cmd, &myflock);
01338 if (status < 0) {
01339
01340
01341 status = SYS_FS_LOCK_ERR - errno;
01342 rodsLogError( LOG_DEBUG, status,"fsDataObjLock: fcntl error for %s, cmd = %d, type = %d",
01343 objPath, cmd, type);
01344
01345 if (path != NULL) free (path);
01346
01347 close (myFd);
01348 return (status);
01349 }
01350 #endif
01351 if (path != NULL) free (path);
01352 if (type == F_UNLCK) {
01353 close (myFd);
01354 myFd = 0;
01355 } else if (cmd == F_GETLK) {
01356
01357 close (myFd);
01358 myFd = myflock.l_type;
01359 }
01360 return (myFd);
01361 }
01362
01363 int
01364 getLeafRescPathName(
01365 const std::string& _resc_hier,
01366 std::string& _ret_string)
01367 {
01368 int result = 0;
01369 eirods::hierarchy_parser hp;
01370 eirods::error ret;
01371 ret = hp.set_string(_resc_hier);
01372 if(!ret.ok()) {
01373 std::stringstream msg;
01374 msg << "Unable to parse hierarchy string: \"" << _resc_hier << "\"";
01375 eirods::log(LOG_ERROR, msg.str());
01376 result = ret.code();
01377 } else {
01378 std::string leaf;
01379 ret = hp.last_resc(leaf);
01380 if(!ret.ok()) {
01381 std::stringstream msg;
01382 msg << "Unable to retrieve last resource from hierarchy string: \"" << _resc_hier << "\"";
01383 eirods::log(LOG_ERROR, msg.str());
01384 result = ret.code();
01385 } else {
01386 ret = eirods::get_resource_property<std::string>(leaf, eirods::RESOURCE_PATH, _ret_string);
01387 if(!ret.ok()) {
01388 std::stringstream msg;
01389 msg << "Unable to get vault path from resource: \"" << leaf << "\"";
01390 eirods::log(LOG_ERROR, msg.str());
01391 result = ret.code();
01392 }
01393 }
01394 }
01395 return result;
01396 }
01397
01398
01399