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