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