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