00001
00002
00003
00004
00005
00006 #include "apiHeaderAll.h"
00007 #include "objMetaOpr.h"
00008 #include "resource.h"
00009 #include "collection.h"
00010 #include "specColl.h"
00011 #include "dataObjOpr.h"
00012 #include "physPath.h"
00013 #include "miscServerFunct.h"
00014 #include "rcGlobalExtern.h"
00015 #include "reGlobalsExtern.h"
00016
00017 int
00018 rsBulkDataObjPut (rsComm_t *rsComm, bulkOprInp_t *bulkOprInp,
00019 bytesBuf_t *bulkOprInpBBuf)
00020 {
00021 int status;
00022 int remoteFlag;
00023 rodsServerHost_t *rodsServerHost;
00024 specCollCache_t *specCollCache = NULL;
00025 dataObjInp_t dataObjInp;
00026
00027 resolveLinkedPath (rsComm, bulkOprInp->objPath, &specCollCache,
00028 &bulkOprInp->condInput);
00029
00030
00031 initDataObjInpFromBulkOpr (&dataObjInp, bulkOprInp);
00032
00033 remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost,
00034 REMOTE_CREATE);
00035
00036 if (remoteFlag < 0) {
00037 return (remoteFlag);
00038 } else if (remoteFlag == LOCAL_HOST) {
00039 status = _rsBulkDataObjPut (rsComm, bulkOprInp, bulkOprInpBBuf);
00040 } else {
00041 status = rcBulkDataObjPut (rodsServerHost->conn, bulkOprInp,
00042 bulkOprInpBBuf);
00043 }
00044 return status;
00045 }
00046
00047 int
00048 _rsBulkDataObjPut (rsComm_t *rsComm, bulkOprInp_t *bulkOprInp,
00049 bytesBuf_t *bulkOprInpBBuf)
00050 {
00051 int status;
00052 int remoteFlag;
00053 rodsServerHost_t *rodsServerHost;
00054 rescInfo_t *rescInfo;
00055 char *inpRescGrpName;
00056 char phyBunDir[MAX_NAME_LEN];
00057 rescGrpInfo_t *myRescGrpInfo = NULL;
00058 int flags = 0;
00059 dataObjInp_t dataObjInp;
00060 fileDriverType_t fileType;
00061 rodsObjStat_t *myRodsObjStat = NULL;
00062
00063 inpRescGrpName = getValByKey (&bulkOprInp->condInput, RESC_GROUP_NAME_KW);
00064
00065 status = chkCollForExtAndReg (rsComm, bulkOprInp->objPath, &myRodsObjStat);
00066 if (status < 0 || myRodsObjStat == NULL ) return status;
00067
00068
00069
00070
00071 initDataObjInpFromBulkOpr (&dataObjInp, bulkOprInp);
00072
00073 if (myRodsObjStat->specColl != NULL) {
00074 status = resolveResc (myRodsObjStat->specColl->resource, &rescInfo);
00075 if (status < 0) {
00076 rodsLog (LOG_ERROR,
00077 "_rsBulkDataObjPut: resolveResc error for %s, status = %d",
00078 myRodsObjStat->specColl->resource, status);
00079 freeRodsObjStat (myRodsObjStat);
00080 return (status);
00081 }
00082 } else {
00083 status = getRescGrpForCreate (rsComm, &dataObjInp, &myRescGrpInfo);
00084 if (status < 0 || myRescGrpInfo == NULL ) {
00085 freeRodsObjStat (myRodsObjStat);
00086 return status;
00087 }
00088
00089
00090 rescInfo = myRescGrpInfo->rescInfo;
00091 }
00092 fileType = (fileDriverType_t)getRescType (rescInfo);
00093 if (fileType != UNIX_FILE_TYPE && fileType != NT_FILE_TYPE) {
00094 freeRodsObjStat (myRodsObjStat);
00095 return SYS_INVALID_RESC_FOR_BULK_OPR;
00096 }
00097
00098 remoteFlag = resolveHostByRescInfo (rescInfo, &rodsServerHost);
00099
00100 if (remoteFlag == REMOTE_HOST) {
00101 addKeyVal (&bulkOprInp->condInput, DEST_RESC_NAME_KW,
00102 rescInfo->rescName);
00103 if (myRodsObjStat->specColl == NULL && inpRescGrpName == NULL &&
00104 strlen (myRescGrpInfo->rescGroupName) > 0) {
00105 addKeyVal (&bulkOprInp->condInput, RESC_GROUP_NAME_KW,
00106 myRescGrpInfo->rescGroupName);
00107 }
00108 freeRodsObjStat (myRodsObjStat);
00109 if ((status = svrToSvrConnect (rsComm, rodsServerHost)) < 0) {
00110 return status;
00111 }
00112 status = rcBulkDataObjPut (rodsServerHost->conn, bulkOprInp,
00113 bulkOprInpBBuf);
00114 freeAllRescGrpInfo (myRescGrpInfo);
00115 return status;
00116 }
00117
00118 status = createBunDirForBulkPut (rsComm, &dataObjInp, rescInfo,
00119 myRodsObjStat->specColl, phyBunDir);
00120
00121 if (status < 0) {
00122 freeRodsObjStat (myRodsObjStat);
00123 return status;
00124 }
00125
00126 #ifdef BULK_OPR_WITH_TAR
00127 status = untarBuf (phyBunDir, bulkOprInpBBuf);
00128 if (status < 0) {
00129 rodsLog (LOG_ERROR,
00130 "_rsBulkDataObjPut: untarBuf for dir %s. stat = %d",
00131 phyBunDir, status);
00132 return status;
00133 }
00134 #else
00135 status = unbunBulkBuf (phyBunDir, bulkOprInp, bulkOprInpBBuf);
00136 if (status < 0) {
00137 rodsLog (LOG_ERROR,
00138 "_rsBulkDataObjPut: unbunBulkBuf for dir %s. stat = %d",
00139 phyBunDir, status);
00140 return status;
00141 }
00142 #endif
00143 if (myRodsObjStat->specColl != NULL) {
00144 freeRodsObjStat (myRodsObjStat);
00145 return status;
00146 } else {
00147 freeRodsObjStat (myRodsObjStat);
00148 }
00149
00150 if (strlen (myRescGrpInfo->rescGroupName) > 0)
00151 inpRescGrpName = myRescGrpInfo->rescGroupName;
00152
00153 if (getValByKey (&bulkOprInp->condInput, FORCE_FLAG_KW) != NULL) {
00154 flags = flags | FORCE_FLAG_FLAG;
00155 }
00156
00157 if (getValByKey (&bulkOprInp->condInput, VERIFY_CHKSUM_KW) != NULL) {
00158 flags = flags | VERIFY_CHKSUM_FLAG;
00159 }
00160 #if 0
00161
00162 status = regUnbunSubfiles (rsComm, rescInfo, inpRescGrpName,
00163 bulkOprInp->objPath, phyBunDir, flags, &bulkOprInp->attriArray);
00164 #else
00165 status = bulkRegUnbunSubfiles (rsComm, rescInfo, inpRescGrpName,
00166 bulkOprInp->objPath, phyBunDir, flags, &bulkOprInp->attriArray);
00167 #endif
00168
00169 if (status == CAT_NO_ROWS_FOUND) {
00170
00171 status = 0;
00172 } else if (status < 0) {
00173 rodsLog (LOG_ERROR,
00174 "_rsBulkDataObjPut: regUnbunSubfiles for dir %s. stat = %d",
00175 phyBunDir, status);
00176 }
00177 freeAllRescGrpInfo (myRescGrpInfo);
00178 return status;
00179 }
00180
00181 int
00182 createBunDirForBulkPut (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00183 rescInfo_t *rescInfo, specColl_t *specColl, char *phyBunDir)
00184 {
00185 dataObjInfo_t dataObjInfo;
00186 #ifndef USE_BOOST_FS
00187 struct stat statbuf;
00188 #endif
00189 int status;
00190
00191 if (dataObjInp == NULL || rescInfo == NULL || phyBunDir == NULL)
00192 return USER__NULL_INPUT_ERR;
00193
00194 if (specColl != NULL) {
00195 status = getMountedSubPhyPath (specColl->collection,
00196 specColl->phyPath, dataObjInp->objPath, phyBunDir);
00197 if (status >= 0) {
00198 mkdirR ("/", phyBunDir, getDefDirMode ());
00199 }
00200 return status;
00201 }
00202 bzero (&dataObjInfo, sizeof (dataObjInfo));
00203 rstrcpy (dataObjInfo.objPath, dataObjInp->objPath, MAX_NAME_LEN);
00204 rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
00205 dataObjInfo.rescInfo = rescInfo;
00206
00207 status = getFilePathName (rsComm, &dataObjInfo, dataObjInp);
00208 if (status < 0) {
00209 rodsLog (LOG_ERROR,
00210 "createBunDirForBulkPut: getFilePathName err for %s. status = %d",
00211 dataObjInp->objPath, status);
00212 return (status);
00213 }
00214 do {
00215 snprintf (phyBunDir, MAX_NAME_LEN, "%s/%s.%d", dataObjInfo.filePath,
00216 TMP_PHY_BUN_DIR, (int) random ());
00217 #ifdef USE_BOOST_FS
00218 path p (phyBunDir);
00219 if (exists (p)) status = 0;
00220 else status = -1;
00221 #else
00222 status = stat (phyBunDir, &statbuf);
00223 #endif
00224 } while (status == 0);
00225
00226 mkdirR ("/", phyBunDir, getDefDirMode ());
00227
00228 return 0;
00229 }
00230
00231 int
00232 initDataObjInpFromBulkOpr (dataObjInp_t *dataObjInp, bulkOprInp_t *bulkOprInp)
00233 {
00234 if (dataObjInp == NULL || bulkOprInp == NULL)
00235 return USER__NULL_INPUT_ERR;
00236
00237 bzero (dataObjInp, sizeof (dataObjInp_t));
00238 rstrcpy (dataObjInp->objPath, bulkOprInp->objPath, MAX_NAME_LEN);
00239 dataObjInp->condInput = bulkOprInp->condInput;
00240
00241 return (0);
00242 }
00243
00244 int
00245 bulkRegUnbunSubfiles (rsComm_t *rsComm, rescInfo_t *rescInfo,
00246 char *rescGroupName, char *collection, char *phyBunDir, int flags,
00247 genQueryOut_t *attriArray)
00248 {
00249 genQueryOut_t bulkDataObjRegInp;
00250 renamedPhyFiles_t renamedPhyFiles;
00251 int status = 0;
00252
00253 bzero (&renamedPhyFiles, sizeof (renamedPhyFiles));
00254 initBulkDataObjRegInp (&bulkDataObjRegInp);
00255
00256 if (attriArray != NULL) attriArray->continueInx = 0;
00257
00258 status = _bulkRegUnbunSubfiles (rsComm, rescInfo, rescGroupName, collection,
00259 phyBunDir, flags, &bulkDataObjRegInp, &renamedPhyFiles, attriArray);
00260
00261 if (bulkDataObjRegInp.rowCnt > 0) {
00262 int status1;
00263 genQueryOut_t *bulkDataObjRegOut = NULL;
00264 status1 = rsBulkDataObjReg (rsComm, &bulkDataObjRegInp,
00265 &bulkDataObjRegOut);
00266 if (status1 < 0) {
00267 status = status1;
00268 rodsLog (LOG_ERROR,
00269 "regUnbunSubfiles: rsBulkDataObjReg error for %s. stat = %d",
00270 collection, status1);
00271 cleanupBulkRegFiles (rsComm, &bulkDataObjRegInp);
00272 }
00273 postProcRenamedPhyFiles (&renamedPhyFiles, status);
00274 postProcBulkPut (rsComm, &bulkDataObjRegInp, bulkDataObjRegOut);
00275 freeGenQueryOut (&bulkDataObjRegOut);
00276 }
00277 clearGenQueryOut (&bulkDataObjRegInp);
00278 return status;
00279 }
00280
00281 int
00282 _bulkRegUnbunSubfiles (rsComm_t *rsComm, rescInfo_t *rescInfo,
00283 char *rescGroupName, char *collection, char *phyBunDir, int flags,
00284 genQueryOut_t *bulkDataObjRegInp, renamedPhyFiles_t *renamedPhyFiles,
00285 genQueryOut_t *attriArray)
00286 {
00287 #ifndef USE_BOOST_FS
00288 DIR *dirPtr;
00289 struct dirent *myDirent;
00290 struct stat statbuf;
00291 #endif
00292 char subfilePath[MAX_NAME_LEN];
00293 char subObjPath[MAX_NAME_LEN];
00294 dataObjInp_t dataObjInp;
00295 int status;
00296 int savedStatus = 0;
00297 int st_mode;
00298 rodsLong_t st_size;
00299
00300 #ifdef USE_BOOST_FS
00301 path srcDirPath (phyBunDir);
00302 if (!exists(srcDirPath) || !is_directory(srcDirPath)) {
00303 #else
00304 dirPtr = opendir (phyBunDir);
00305 if (dirPtr == NULL) {
00306 #endif
00307 rodsLog (LOG_ERROR,
00308 "regUnbunphySubfiles: opendir error for %s, errno = %d",
00309 phyBunDir, errno);
00310 return (UNIX_FILE_OPENDIR_ERR - errno);
00311 }
00312 bzero (&dataObjInp, sizeof (dataObjInp));
00313 #ifdef USE_BOOST_FS
00314 directory_iterator end_itr;
00315 for (directory_iterator itr(srcDirPath); itr != end_itr;++itr) {
00316 path p = itr->path();
00317 snprintf (subfilePath, MAX_NAME_LEN, "%s",
00318 p.c_str ());
00319 #else
00320 while ((myDirent = readdir (dirPtr)) != NULL) {
00321 if (strcmp (myDirent->d_name, ".") == 0 ||
00322 strcmp (myDirent->d_name, "..") == 0) {
00323 continue;
00324 }
00325 snprintf (subfilePath, MAX_NAME_LEN, "%s/%s",
00326 phyBunDir, myDirent->d_name);
00327 #endif
00328
00329 #ifdef USE_BOOST_FS
00330 if (!exists (p)) {
00331 #else
00332 status = stat (subfilePath, &statbuf);
00333
00334 if (status != 0) {
00335 #endif
00336 rodsLog (LOG_ERROR,
00337 "regUnbunphySubfiles: stat error for %s, errno = %d",
00338 subfilePath, errno);
00339 savedStatus = UNIX_FILE_STAT_ERR - errno;
00340 unlink (subfilePath);
00341 continue;
00342 }
00343
00344 #ifdef USE_BOOST_FS
00345 path childPath = p.filename();
00346 snprintf (subObjPath, MAX_NAME_LEN, "%s/%s",
00347 collection, childPath.c_str());
00348 if (is_directory (p)) {
00349 #else
00350 snprintf (subObjPath, MAX_NAME_LEN, "%s/%s",
00351 collection, myDirent->d_name);
00352 if ((statbuf.st_mode & S_IFDIR) != 0) {
00353 #endif
00354 status = rsMkCollR (rsComm, "/", subObjPath);
00355 if (status < 0) {
00356 rodsLog (LOG_ERROR,
00357 "regUnbunSubfiles: rsMkCollR of %s error. status = %d",
00358 subObjPath, status);
00359 savedStatus = status;
00360 continue;
00361 }
00362 status = _bulkRegUnbunSubfiles (rsComm, rescInfo, rescGroupName,
00363 subObjPath, subfilePath, flags, bulkDataObjRegInp,
00364 renamedPhyFiles, attriArray);
00365 if (status < 0) {
00366 rodsLog (LOG_ERROR,
00367 "regUnbunSubfiles: regUnbunSubfiles of %s error. status=%d",
00368 subObjPath, status);
00369 savedStatus = status;
00370 continue;
00371 }
00372 #ifdef USE_BOOST_FS
00373 } else if (is_regular_file (p)) {
00374 st_mode = getPathStMode (p);
00375 st_size = file_size (p);
00376 #else
00377 } else if ((statbuf.st_mode & S_IFREG) != 0) {
00378 st_mode = statbuf.st_mode;
00379 st_size = statbuf.st_size;
00380 #endif
00381 status = bulkProcAndRegSubfile (rsComm, rescInfo, rescGroupName,
00382 subObjPath, subfilePath, st_size,
00383 st_mode & 0777, flags, bulkDataObjRegInp,
00384 renamedPhyFiles, attriArray);
00385 unlink (subfilePath);
00386 if (status < 0) {
00387 rodsLog (LOG_ERROR,
00388 "regUnbunSubfiles:bulkProcAndRegSubfile of %s err.stat=%d",
00389 subObjPath, status);
00390 savedStatus = status;
00391 continue;
00392 }
00393 }
00394 }
00395 #ifndef USE_BOOST_FS
00396 closedir (dirPtr);
00397 #endif
00398 rmdir (phyBunDir);
00399 return savedStatus;
00400 }
00401
00402 int
00403 bulkProcAndRegSubfile (rsComm_t *rsComm, rescInfo_t *rescInfo,
00404 char *rescGroupName, char *subObjPath, char *subfilePath, rodsLong_t dataSize,
00405 int dataMode, int flags, genQueryOut_t *bulkDataObjRegInp,
00406 renamedPhyFiles_t *renamedPhyFiles, genQueryOut_t *attriArray)
00407 {
00408 dataObjInfo_t dataObjInfo;
00409 dataObjInp_t dataObjInp;
00410 #ifndef USE_BOOST_FS
00411 struct stat statbuf;
00412 #endif
00413 int status;
00414 int modFlag = 0;
00415 char *myChksum = NULL;
00416 int myDataMode = dataMode;
00417
00418 bzero (&dataObjInp, sizeof (dataObjInp));
00419 bzero (&dataObjInfo, sizeof (dataObjInfo));
00420 rstrcpy (dataObjInp.objPath, subObjPath, MAX_NAME_LEN);
00421 rstrcpy (dataObjInfo.objPath, subObjPath, MAX_NAME_LEN);
00422 rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
00423 rstrcpy (dataObjInfo.dataType, "generic", NAME_LEN);
00424 dataObjInfo.rescInfo = rescInfo;
00425 dataObjInfo.dataSize = dataSize;
00426
00427 status = getFilePathName (rsComm, &dataObjInfo, &dataObjInp);
00428 if (status < 0) {
00429 rodsLog (LOG_ERROR,
00430 "regSubFile: getFilePathName err for %s. status = %d",
00431 dataObjInp.objPath, status);
00432 return (status);
00433 }
00434
00435 #ifdef USE_BOOST_FS
00436 path p (dataObjInfo.filePath);
00437 if (exists (p)) {
00438 if (is_directory (p)) {
00439 #else
00440 status = stat (dataObjInfo.filePath, &statbuf);
00441 if (status == 0 || errno != ENOENT) {
00442 if ((statbuf.st_mode & S_IFDIR) != 0) {
00443 #endif
00444 return SYS_PATH_IS_NOT_A_FILE;
00445 }
00446 if (chkOrphanFile (rsComm, dataObjInfo.filePath, rescInfo->rescName,
00447 &dataObjInfo) <= 0) {
00448
00449 if ((flags & FORCE_FLAG_FLAG) != 0 && dataObjInfo.dataId > 0 &&
00450 strcmp (dataObjInfo.objPath, subObjPath) == 0) {
00451
00452 modFlag = 1;
00453 } else {
00454 status = SYS_COPY_ALREADY_IN_RESC;
00455 rodsLog (LOG_ERROR,
00456 "bulkProcAndRegSubfile: phypath %s is already in use. status = %d",
00457 dataObjInfo.filePath, status);
00458 return (status);
00459 }
00460 }
00461
00462 fileRenameInp_t fileRenameInp;
00463 bzero (&fileRenameInp, sizeof (fileRenameInp));
00464 rstrcpy (fileRenameInp.oldFileName, dataObjInfo.filePath,
00465 MAX_NAME_LEN);
00466 status = renameFilePathToNewDir (rsComm, ORPHAN_DIR,
00467 &fileRenameInp, rescInfo, 1);
00468 if (status < 0) {
00469 rodsLog (LOG_ERROR,
00470 "bulkProcAndRegSubfile: renameFilePathToNewDir err for %s. status = %d",
00471 fileRenameInp.oldFileName, status);
00472 return (status);
00473 }
00474 if (modFlag > 0) {
00475 status = addRenamedPhyFile (subObjPath, fileRenameInp.oldFileName,
00476 fileRenameInp.newFileName, renamedPhyFiles);
00477 if (status < 0) return status;
00478 }
00479 } else {
00480
00481 mkDirForFilePath (UNIX_FILE_TYPE, rsComm, "/", dataObjInfo.filePath,
00482 getDefDirMode ());
00483 }
00484
00485 #ifndef windows_platform
00486 status = link (subfilePath, dataObjInfo.filePath);
00487 if (status < 0) {
00488 rodsLog (LOG_ERROR,
00489 "bulkProcAndRegSubfile: link error %s to %s. errno = %d",
00490 subfilePath, dataObjInfo.filePath, errno);
00491 return (UNIX_FILE_LINK_ERR - errno);
00492 }
00493 #endif
00494
00495 if (attriArray != NULL) {
00496
00497 status =getAttriInAttriArray (subObjPath, attriArray, &myDataMode,
00498 &myChksum);
00499 if (status < 0) {
00500 rodsLog (LOG_NOTICE,
00501 "bulkProcAndRegSubfile: matchObjPath error for %s, stat = %d",
00502 subObjPath, status);
00503 } else {
00504 if ((flags & VERIFY_CHKSUM_FLAG) != 0 && myChksum != NULL) {
00505 char chksumStr[NAME_LEN];
00506
00507 status = chksumLocFile (dataObjInfo.filePath, chksumStr);
00508 if (status < 0) {
00509 rodsLog (LOG_ERROR,
00510 "bulkProcAndRegSubfile: chksumLocFile error for %s ",
00511 dataObjInfo.filePath);
00512 return (status);
00513 }
00514 if (strcmp (myChksum, chksumStr) != 0) {
00515 rodsLog (LOG_ERROR,
00516 "bulkProcAndRegSubfile: chksum of %s %s != input %s",
00517 dataObjInfo.filePath, chksumStr, myChksum);
00518 return (USER_CHKSUM_MISMATCH);
00519 }
00520 }
00521 }
00522 }
00523
00524 status = bulkRegSubfile (rsComm, rescInfo->rescName, rescGroupName,
00525 subObjPath, dataObjInfo.filePath, dataSize, myDataMode, modFlag,
00526 dataObjInfo.replNum, myChksum, bulkDataObjRegInp, renamedPhyFiles);
00527
00528 return status;
00529 }
00530
00531 int
00532 bulkRegSubfile (rsComm_t *rsComm, char *rescName, char *rescGroupName,
00533 char *subObjPath, char *subfilePath, rodsLong_t dataSize, int dataMode,
00534 int modFlag, int replNum, char *chksum, genQueryOut_t *bulkDataObjRegInp,
00535 renamedPhyFiles_t *renamedPhyFiles)
00536 {
00537 int status;
00538
00539
00540 status = fillBulkDataObjRegInp (rescName, rescGroupName, subObjPath,
00541 subfilePath, "generic", dataSize, dataMode, modFlag,
00542 replNum, chksum, bulkDataObjRegInp);
00543 if (status < 0) {
00544 rodsLog (LOG_ERROR,
00545 "bulkRegSubfile: fillBulkDataObjRegInp error for %s. status = %d",
00546 subfilePath, status);
00547 return status;
00548 }
00549
00550 if (bulkDataObjRegInp->rowCnt >= MAX_NUM_BULK_OPR_FILES) {
00551 genQueryOut_t *bulkDataObjRegOut = NULL;
00552 status = rsBulkDataObjReg (rsComm, bulkDataObjRegInp,
00553 &bulkDataObjRegOut);
00554 if (status < 0) {
00555 rodsLog (LOG_ERROR,
00556 "bulkRegSubfile: rsBulkDataObjReg error for %s. status = %d",
00557 subfilePath, status);
00558 cleanupBulkRegFiles (rsComm, bulkDataObjRegInp);
00559 }
00560 postProcRenamedPhyFiles (renamedPhyFiles, status);
00561 postProcBulkPut (rsComm, bulkDataObjRegInp, bulkDataObjRegOut);
00562 freeGenQueryOut (&bulkDataObjRegOut);
00563 bulkDataObjRegInp->rowCnt = 0;
00564 }
00565 return status;
00566 }
00567
00568 int
00569 addRenamedPhyFile (char *subObjPath, char *oldFileName, char *newFileName,
00570 renamedPhyFiles_t *renamedPhyFiles)
00571 {
00572 if (subObjPath == NULL || oldFileName == NULL || newFileName == NULL ||
00573 renamedPhyFiles == NULL) return USER__NULL_INPUT_ERR;
00574
00575 if (renamedPhyFiles->count >= MAX_NUM_BULK_OPR_FILES) {
00576 rodsLog (LOG_ERROR,
00577 "addRenamedPhyFile: count >= %d for %s", MAX_NUM_BULK_OPR_FILES,
00578 subObjPath);
00579 return (SYS_RENAME_STRUCT_COUNT_EXCEEDED);
00580 }
00581 rstrcpy (&renamedPhyFiles->objPath[renamedPhyFiles->count][0],
00582 subObjPath, MAX_NAME_LEN);
00583 rstrcpy (&renamedPhyFiles->origFilePath[renamedPhyFiles->count][0],
00584 oldFileName, MAX_NAME_LEN);
00585 rstrcpy (&renamedPhyFiles->newFilePath[renamedPhyFiles->count][0],
00586 newFileName, MAX_NAME_LEN);
00587 renamedPhyFiles->count++;
00588 return 0;
00589 }
00590
00591 int
00592 postProcRenamedPhyFiles (renamedPhyFiles_t *renamedPhyFiles, int regStatus)
00593 {
00594 int i;
00595 int status = 0;
00596 int savedStatus = 0;
00597
00598 if (renamedPhyFiles == NULL) return USER__NULL_INPUT_ERR;
00599
00600 if (regStatus >= 0) {
00601 for (i = 0; i < renamedPhyFiles->count; i++) {
00602 unlink (&renamedPhyFiles->newFilePath[i][0]);
00603 }
00604 } else {
00605
00606 for (i = 0; i < renamedPhyFiles->count; i++) {
00607 status = rename (&renamedPhyFiles->newFilePath[i][0],
00608 &renamedPhyFiles->origFilePath[i][0]);
00609 savedStatus = UNIX_FILE_RENAME_ERR - errno;
00610 rodsLog (LOG_ERROR,
00611 "postProcRenamedPhyFiles: rename error from %s to %s, status=%d",
00612 &renamedPhyFiles->newFilePath[i][0],
00613 &renamedPhyFiles->origFilePath[i][0], savedStatus);
00614 }
00615 }
00616 bzero (renamedPhyFiles, sizeof (renamedPhyFiles_t));
00617
00618 return savedStatus;
00619 }
00620
00621 int
00622 cleanupBulkRegFiles (rsComm_t *rsComm, genQueryOut_t *bulkDataObjRegInp)
00623 {
00624 sqlResult_t *filePath, *rescName;
00625 char *tmpFilePath, *tmpRescName;
00626 int i;
00627
00628 if (bulkDataObjRegInp == NULL) return USER__NULL_INPUT_ERR;
00629
00630 if ((filePath =
00631 getSqlResultByInx (bulkDataObjRegInp, COL_D_DATA_PATH)) == NULL) {
00632 rodsLog (LOG_NOTICE,
00633 "cleanupBulkRegFiles: getSqlResultByInx for COL_D_DATA_PATH failed");
00634 return (UNMATCHED_KEY_OR_INDEX);
00635 }
00636 if ((rescName =
00637 getSqlResultByInx (bulkDataObjRegInp, COL_D_RESC_NAME)) == NULL) {
00638 rodsLog (LOG_NOTICE,
00639 "rsBulkDataObjReg: getSqlResultByInx for COL_D_RESC_NAME failed");
00640 return (UNMATCHED_KEY_OR_INDEX);
00641 }
00642
00643 for (i = 0;i < bulkDataObjRegInp->rowCnt; i++) {
00644 tmpFilePath = &filePath->value[filePath->len * i];
00645 tmpRescName = &rescName->value[rescName->len * i];
00646
00647 if (chkOrphanFile (rsComm, tmpFilePath, tmpRescName, NULL) > 0) {
00648 unlink (tmpFilePath);
00649 }
00650 }
00651
00652 return 0;
00653 }
00654
00655 int
00656 postProcBulkPut (rsComm_t *rsComm, genQueryOut_t *bulkDataObjRegInp,
00657 genQueryOut_t *bulkDataObjRegOut)
00658 {
00659 dataObjInfo_t dataObjInfo;
00660 sqlResult_t *objPath, *dataType, *dataSize, *rescName, *filePath,
00661 *dataMode, *oprType, *rescGroupName, *replNum, *chksum;
00662 char *tmpObjPath, *tmpDataType, *tmpDataSize, *tmpFilePath,
00663 *tmpDataMode, *tmpOprType, *tmpReplNum, *tmpChksum;
00664 sqlResult_t *objId;
00665 char *tmpObjId;
00666 int status, i;
00667 dataObjInp_t dataObjInp;
00668 ruleExecInfo_t rei;
00669 int savedStatus = 0;
00670
00671 if (bulkDataObjRegInp == NULL || bulkDataObjRegOut == NULL)
00672 return USER__NULL_INPUT_ERR;
00673
00674 initReiWithDataObjInp (&rei, rsComm, NULL);
00675 status = applyRule ("acBulkPutPostProcPolicy", NULL, &rei, NO_SAVE_REI);
00676 if (status < 0) {
00677 rodsLog (LOG_ERROR,
00678 "postProcBulkPut: acBulkPutPostProcPolicy error status = %d", status);
00679 return status;
00680 }
00681
00682 if (rei.status == POLICY_OFF) return 0;
00683
00684 if ((objPath =
00685 getSqlResultByInx (bulkDataObjRegInp, COL_DATA_NAME)) == NULL) {
00686 rodsLog (LOG_ERROR,
00687 "postProcBulkPut: getSqlResultByInx for COL_DATA_NAME failed");
00688 return (UNMATCHED_KEY_OR_INDEX);
00689 }
00690
00691 if ((dataType =
00692 getSqlResultByInx (bulkDataObjRegInp, COL_DATA_TYPE_NAME)) == NULL) {
00693 rodsLog (LOG_ERROR,
00694 "postProcBulkPut: getSqlResultByInx for COL_DATA_TYPE_NAME failed");
00695 return (UNMATCHED_KEY_OR_INDEX);
00696 }
00697 if ((dataSize =
00698 getSqlResultByInx (bulkDataObjRegInp, COL_DATA_SIZE)) == NULL) {
00699 rodsLog (LOG_ERROR,
00700 "postProcBulkPut: getSqlResultByInx for COL_DATA_SIZE failed");
00701 return (UNMATCHED_KEY_OR_INDEX);
00702 }
00703 if ((rescName =
00704 getSqlResultByInx (bulkDataObjRegInp, COL_D_RESC_NAME)) == NULL) {
00705 rodsLog (LOG_ERROR,
00706 "postProcBulkPut: getSqlResultByInx for COL_D_RESC_NAME failed");
00707 return (UNMATCHED_KEY_OR_INDEX);
00708 }
00709
00710 if ((filePath =
00711 getSqlResultByInx (bulkDataObjRegInp, COL_D_DATA_PATH)) == NULL) {
00712 rodsLog (LOG_ERROR,
00713 "postProcBulkPut: getSqlResultByInx for COL_D_DATA_PATH failed");
00714 return (UNMATCHED_KEY_OR_INDEX);
00715 }
00716
00717 if ((dataMode =
00718 getSqlResultByInx (bulkDataObjRegInp, COL_DATA_MODE)) == NULL) {
00719 rodsLog (LOG_ERROR,
00720 "postProcBulkPut: getSqlResultByInx for COL_DATA_MODE failed");
00721 return (UNMATCHED_KEY_OR_INDEX);
00722 }
00723
00724 if ((oprType =
00725 getSqlResultByInx (bulkDataObjRegInp, OPR_TYPE_INX)) == NULL) {
00726 rodsLog (LOG_ERROR,
00727 "postProcBulkPut: getSqlResultByInx for OPR_TYPE_INX failed");
00728 return (UNMATCHED_KEY_OR_INDEX);
00729 }
00730
00731 if ((rescGroupName =
00732 getSqlResultByInx (bulkDataObjRegInp, COL_RESC_GROUP_NAME)) == NULL) {
00733 rodsLog (LOG_ERROR,
00734 "postProcBulkPut: getSqlResultByInx for COL_RESC_GROUP_NAME failed");
00735 return (UNMATCHED_KEY_OR_INDEX);
00736 }
00737
00738 if ((replNum =
00739 getSqlResultByInx (bulkDataObjRegInp, COL_DATA_REPL_NUM)) == NULL) {
00740 rodsLog (LOG_ERROR,
00741 "postProcBulkPut: getSqlResultByInx for COL_DATA_REPL_NUM failed");
00742 return (UNMATCHED_KEY_OR_INDEX);
00743 }
00744 chksum = getSqlResultByInx (bulkDataObjRegInp, COL_D_DATA_CHECKSUM);
00745
00746
00747 if ((objId =
00748 getSqlResultByInx (bulkDataObjRegOut, COL_D_DATA_ID)) == NULL) {
00749 rodsLog (LOG_ERROR,
00750 "postProcBulkPut: getSqlResultByInx for COL_D_DATA_ID failed");
00751 return (UNMATCHED_KEY_OR_INDEX);
00752 }
00753
00754
00755 bzero (&dataObjInfo, sizeof (dataObjInfo_t));
00756 rstrcpy (dataObjInfo.rescName, rescName->value, NAME_LEN);
00757 rstrcpy (dataObjInfo.rescGroupName, rescGroupName->value, NAME_LEN);
00758 dataObjInfo.replStatus = NEWLY_CREATED_COPY;
00759 status = resolveResc (rescName->value, &dataObjInfo.rescInfo);
00760 if (status < 0) {
00761 rodsLog (LOG_ERROR,
00762 "postProcBulkPut: resolveResc error for %s, status = %d",
00763 rescName->value, status);
00764 return (status);
00765 }
00766 bzero (&dataObjInp, sizeof (dataObjInp_t));
00767 dataObjInp.openFlags = O_WRONLY;
00768
00769 for (i = 0;i < bulkDataObjRegInp->rowCnt; i++) {
00770 dataObjInfo_t *tmpDataObjInfo;
00771
00772 tmpDataObjInfo = (dataObjInfo_t *)malloc (sizeof (dataObjInfo_t));
00773 if (tmpDataObjInfo == NULL) return SYS_MALLOC_ERR;
00774
00775 *tmpDataObjInfo = dataObjInfo;
00776
00777 tmpObjPath = &objPath->value[objPath->len * i];
00778 tmpDataType = &dataType->value[dataType->len * i];
00779 tmpDataSize = &dataSize->value[dataSize->len * i];
00780 tmpFilePath = &filePath->value[filePath->len * i];
00781 tmpDataMode = &dataMode->value[dataMode->len * i];
00782 tmpOprType = &oprType->value[oprType->len * i];
00783 tmpReplNum = &replNum->value[replNum->len * i];
00784 tmpObjId = &objId->value[objId->len * i];
00785
00786 rstrcpy (tmpDataObjInfo->objPath, tmpObjPath, MAX_NAME_LEN);
00787 rstrcpy (dataObjInp.objPath, tmpObjPath, MAX_NAME_LEN);
00788 rstrcpy (tmpDataObjInfo->dataType, tmpDataType, NAME_LEN);
00789 tmpDataObjInfo->dataSize = strtoll (tmpDataSize, 0, 0);
00790 #if 0
00791 rstrcpy (tmpDataObjInfo->rescName, tmpRescName, NAME_LEN);
00792 rstrcpy (tmpDataObjInfo->rescGroupName, tmpRescGroupName, NAME_LEN);
00793 #endif
00794 rstrcpy (tmpDataObjInfo->filePath, tmpFilePath, MAX_NAME_LEN);
00795 rstrcpy (tmpDataObjInfo->dataMode, tmpDataMode, NAME_LEN);
00796 tmpDataObjInfo->replNum = atoi (tmpReplNum);
00797 if (chksum != NULL) {
00798 tmpChksum = &chksum->value[chksum->len * i];
00799 if (strlen (tmpChksum) > 0) {
00800 rstrcpy (tmpDataObjInfo->chksum, tmpChksum, NAME_LEN);
00801 }
00802 }
00803 initReiWithDataObjInp (&rei, rsComm, &dataObjInp);
00804 rei.doi = tmpDataObjInfo;
00805
00806 status = applyRule ("acPostProcForPut", NULL, &rei, NO_SAVE_REI);
00807 if (status < 0) savedStatus = status;
00808
00809 freeAllDataObjInfo (rei.doi);
00810 }
00811 return savedStatus;
00812 }
00813