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