00001
00002
00003
00004
00005
00006
00007
00008 #include "dataObjCopy.h"
00009 #include "rodsLog.h"
00010 #include "objMetaOpr.h"
00011 #include "collection.h"
00012 #include "specColl.h"
00013 #include "dataObjOpen.h"
00014 #include "dataObjCreate.h"
00015 #include "dataObjRepl.h"
00016 #include "regDataObj.h"
00017 #include "rsGlobalExtern.h"
00018 #include "rcGlobalExtern.h"
00019 #include "getRemoteZoneResc.h"
00020
00021
00022
00023 #include "eirods_resource_redirect.h"
00024
00025 int
00026 rsDataObjCopy250 (rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
00027 transStat_t **transStat)
00028 {
00029 int status;
00030 transferStat_t *transferStat = NULL;
00031
00032 status = rsDataObjCopy (rsComm, dataObjCopyInp, &transferStat);
00033
00034 if (transStat != NULL && status >= 0 && transferStat != NULL) {
00035 *transStat = (transStat_t *) malloc (sizeof (transStat_t));
00036 (*transStat)->numThreads = transferStat->numThreads;
00037 (*transStat)->bytesWritten = transferStat->bytesWritten;
00038 free (transferStat);
00039 }
00040 return status;
00041 }
00042
00043 int
00044 rsDataObjCopy (rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
00045 transferStat_t **transStat)
00046 {
00047 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00048 int srcL1descInx, destL1descInx;
00049 int status;
00050 int existFlag;
00051 uint createMode;
00052 int remoteFlag;
00053 rodsServerHost_t *rodsServerHost;
00054 specCollCache_t *specCollCache = NULL;
00055
00056 srcDataObjInp = &dataObjCopyInp->srcDataObjInp;
00057 destDataObjInp = &dataObjCopyInp->destDataObjInp;
00058
00059 resolveLinkedPath (rsComm, srcDataObjInp->objPath, &specCollCache, &srcDataObjInp->condInput);
00060 resolveLinkedPath (rsComm, destDataObjInp->objPath, &specCollCache, &destDataObjInp->condInput);
00061
00062 remoteFlag = getAndConnRemoteZoneForCopy (rsComm, dataObjCopyInp, &rodsServerHost);
00063 if (remoteFlag < 0) {
00064 return (remoteFlag);
00065 } else if (remoteFlag == REMOTE_HOST) {
00066 status = _rcDataObjCopy (rodsServerHost->conn, dataObjCopyInp,
00067 transStat);
00068 return status;
00069 }
00070
00071 #if 0 // this should be handled by rsDataObjCreate and rsDataObjOpen
00072
00073
00074 if(getValByKey(&srcDataObjInp->condInput, RESC_HIER_STR_KW) == NULL) {
00075 std::string hier;
00076 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_OPEN_OPERATION, rsComm,
00077 srcDataObjInp, hier );
00078 if( !ret.ok() ) {
00079 std::stringstream msg;
00080 msg << "rsDataObjCopy :: failed in eirods::resolve_resource_hierarchy for [";
00081 msg << srcDataObjInp->objPath << "]";
00082 eirods::log( PASSMSG( msg.str(), ret ) );
00083 return ret.code();
00084 }
00085
00086
00087
00088 addKeyVal( &srcDataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00089 }
00090
00091
00092
00093 if(getValByKey(&destDataObjInp->condInput, RESC_HIER_STR_KW) == NULL) {
00094 std::string hier;
00095 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_CREATE_OPERATION, rsComm,
00096 destDataObjInp, hier );
00097 if( !ret.ok() ) {
00098 std::stringstream msg;
00099 msg << "rsDataObjCopy :: failed in eirods::resolve_resource_hierarchy for [";
00100 msg << destDataObjInp->objPath << "]";
00101 eirods::log( PASSMSG( msg.str(), ret ) );
00102 return ret.code();
00103 }
00104
00105
00106
00107 addKeyVal( &destDataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00108 }
00109
00110 #endif
00111
00112
00113 #if 0
00114 *transStat = malloc (sizeof (transferStat_t));
00115 memset (*transStat, 0, sizeof (transferStat_t));
00116 #endif
00117
00118 if (strcmp (srcDataObjInp->objPath, destDataObjInp->objPath) == 0) {
00119 rodsLog (LOG_ERROR,
00120 "rsDataObjCopy: same src and dest objPath %s not allowed",
00121 srcDataObjInp->objPath);
00122 return (USER_INPUT_PATH_ERR);
00123 }
00124
00125 addKeyVal (&srcDataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "");
00126
00127 srcL1descInx = rsDataObjOpen (rsComm, srcDataObjInp);
00128
00129 if (srcL1descInx < 0) {
00130 std::stringstream msg;
00131 char* sys_error;
00132 char* rods_error = rodsErrorName(srcL1descInx, &sys_error);
00133 msg << __FUNCTION__;
00134 msg << " - Failed to open source object: \"";
00135 msg << srcDataObjInp->objPath;
00136 msg << "\" - ";
00137 msg << rods_error << " " << sys_error;
00138 eirods::log(LOG_ERROR, msg.str());
00139 return srcL1descInx;
00140 }
00141
00142
00143 destDataObjInp->dataSize = L1desc[srcL1descInx].dataSize =
00144 L1desc[srcL1descInx].dataObjInfo->dataSize;
00145
00146 createMode = atoi (L1desc[srcL1descInx].dataObjInfo->dataMode);
00147
00148 if (createMode >= 0100)
00149 destDataObjInp->createMode = createMode;
00150
00151 L1desc[srcL1descInx].oprType = COPY_SRC;
00152
00153 if (L1desc[srcL1descInx].l3descInx <= 2) {
00154
00155 addKeyVal (&destDataObjInp->condInput, NO_OPEN_FLAG_KW, "");
00156 }
00157
00158 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00159 if (destL1descInx == CAT_UNKNOWN_COLLECTION) {
00160
00161 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00162 splitPathByKey (destDataObjInp->objPath, parColl, child, '/');
00163 rsMkCollR (rsComm, "/", parColl);
00164 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00165 }
00166
00167 if (destL1descInx < 0) {
00168 std::stringstream msg;
00169 char* sys_error;
00170 char* rods_error = rodsErrorName(destL1descInx, &sys_error);
00171 msg << __FUNCTION__;
00172 msg << " - Failed to create destination object: \"";
00173 msg << destDataObjInp->objPath;
00174 msg << "\" - ";
00175 msg << rods_error << " " << sys_error;
00176 eirods::log(LOG_ERROR, msg.str());
00177 return (destL1descInx);
00178 }
00179
00180 if (L1desc[destL1descInx].replStatus == NEWLY_CREATED_COPY) {
00181 existFlag = 0;
00182 } else {
00183 existFlag = 1;
00184 }
00185
00186 L1desc[destL1descInx].oprType = COPY_DEST;
00187
00188 L1desc[destL1descInx].srcL1descInx = srcL1descInx;
00189
00190 rstrcpy (L1desc[destL1descInx].dataObjInfo->dataType,
00191
00192 L1desc[srcL1descInx].dataObjInfo->dataType, NAME_LEN);
00193
00194
00195 L1desc[destL1descInx].dataSize =
00196 L1desc[srcL1descInx].dataObjInfo->dataSize;
00197
00198 #if 0
00199 (*transStat)->bytesWritten = L1desc[srcL1descInx].dataObjInfo->dataSize;
00200 #endif
00201 status = _rsDataObjCopy (rsComm, destL1descInx, existFlag, transStat);
00202
00203 #if 0
00204 if (status >= 0) {
00205 (*transStat)->numThreads = destDataObjInp->numThreads;
00206 }
00207 #endif
00208
00209 return (status);
00210 }
00211
00212 int
00213 _rsDataObjCopy (rsComm_t *rsComm, int destL1descInx, int existFlag,
00214 transferStat_t **transStat)
00215 {
00216 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00217 openedDataObjInp_t dataObjCloseInp;
00218 dataObjInfo_t *srcDataObjInfo, *destDataObjInfo;
00219 int srcL1descInx;
00220 int status = 0, status2;
00221
00222 destDataObjInp = L1desc[destL1descInx].dataObjInp;
00223 destDataObjInfo = L1desc[destL1descInx].dataObjInfo;
00224 srcL1descInx = L1desc[destL1descInx].srcL1descInx;
00225
00226 srcDataObjInp = L1desc[srcL1descInx].dataObjInp;
00227 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00228
00229 if( destDataObjInp == NULL ) {
00230 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInp is NULL" );
00231 return -1;
00232 }
00233 if( destDataObjInfo == NULL ) {
00234 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInfo is NULL" );
00235 return -1;
00236 }
00237 if( srcDataObjInp == NULL ) {
00238 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInp is NULL" );
00239 return -1;
00240 }
00241 if( srcDataObjInfo == NULL ) {
00242 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInfo is NULL" );
00243 return -1;
00244 }
00245
00246 if (L1desc[srcL1descInx].l3descInx <= 2) {
00247
00248
00249 status = l3DataCopySingleBuf (rsComm, destL1descInx);
00250
00251
00252 if( status >= 0 &&
00253 existFlag == 0 &&
00254 destDataObjInfo->specColl == NULL &&
00255 L1desc[destL1descInx].remoteZoneHost == NULL) {
00256
00257 status = svrRegDataObj (rsComm, destDataObjInfo);
00258 if (status == CAT_UNKNOWN_COLLECTION) {
00259
00260 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00261 splitPathByKey (destDataObjInfo->objPath, parColl, child, '/');
00262 status = svrRegDataObj (rsComm, destDataObjInfo);
00263 rsMkCollR (rsComm, "/", parColl);
00264 status = svrRegDataObj (rsComm, destDataObjInfo);
00265 }
00266 if (status < 0) {
00267 rodsLog (LOG_NOTICE,
00268 "_rsDataObjCopy: svrRegDataObj for %s failed, status = %d",
00269 destDataObjInfo->objPath, status);
00270 return (status);
00271 }
00272 }
00273
00274 } else {
00275 if( srcDataObjInfo != NULL ) {
00276 destDataObjInp->numThreads = getNumThreads( rsComm, srcDataObjInfo->dataSize, destDataObjInp->numThreads, NULL,
00277 srcDataObjInfo->rescHier, destDataObjInfo->rescHier );
00278
00279 }
00280
00281 srcDataObjInp->numThreads = destDataObjInp->numThreads;
00282 #if 0
00283
00284 if (destDataObjInp->numThreads == 0 &&
00285 srcDataObjInfo->dataSize > MAX_SZ_FOR_SINGLE_BUF) {
00286 destDataObjInp->numThreads = 1;
00287 }
00288 #endif
00289
00290 status = dataObjCopy (rsComm, destL1descInx);
00291 }
00292
00293 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00294 dataObjCloseInp.l1descInx = destL1descInx;
00295 if (status >= 0) {
00296 *transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
00297 memset (*transStat, 0, sizeof (transferStat_t));
00298 (*transStat)->bytesWritten = srcDataObjInfo->dataSize;
00299 (*transStat)->numThreads = destDataObjInp->numThreads;
00300 dataObjCloseInp.bytesWritten = srcDataObjInfo->dataSize;
00301 }
00302
00303 status2 = rsDataObjClose (rsComm, &dataObjCloseInp);
00304
00305 if (status) return (status);
00306 return(status2);
00307 }
00308