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
00064 if (remoteFlag < 0) {
00065 return (remoteFlag);
00066 } else if (remoteFlag == REMOTE_HOST) {
00067 status = _rcDataObjCopy (rodsServerHost->conn, dataObjCopyInp,
00068 transStat);
00069 return status;
00070 }
00071
00072
00073
00074 std::string hier;
00075 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_OPEN_OPERATION, rsComm,
00076 srcDataObjInp, hier );
00077 if( !ret.ok() ) {
00078 std::stringstream msg;
00079 msg << "rsDataObjCopy :: failed in eirods::resolve_resource_hierarchy for [";
00080 msg << srcDataObjInp->objPath << "]";
00081 eirods::log( PASSMSG( msg.str(), ret ) );
00082 return ret.code();
00083 }
00084
00085
00086
00087 addKeyVal( &srcDataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00088
00089
00090
00091 hier = "";
00092 ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_CREATE_OPERATION, rsComm,
00093 destDataObjInp, hier );
00094 if( !ret.ok() ) {
00095 std::stringstream msg;
00096 msg << "rsDataObjCopy :: failed in eirods::resolve_resource_hierarchy for [";
00097 msg << destDataObjInp->objPath << "]";
00098 eirods::log( PASSMSG( msg.str(), ret ) );
00099 return ret.code();
00100 }
00101
00102
00103
00104 addKeyVal( &destDataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00105
00106 #if 0
00107 *transStat = malloc (sizeof (transferStat_t));
00108 memset (*transStat, 0, sizeof (transferStat_t));
00109 #endif
00110
00111 if (strcmp (srcDataObjInp->objPath, destDataObjInp->objPath) == 0) {
00112 rodsLog (LOG_ERROR,
00113 "rsDataObjCopy: same src and dest objPath %s not allowed",
00114 srcDataObjInp->objPath);
00115 return (USER_INPUT_PATH_ERR);
00116 }
00117
00118 addKeyVal (&srcDataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "");
00119
00120 srcL1descInx = rsDataObjOpen (rsComm, srcDataObjInp);
00121
00122 if (srcL1descInx < 0) {
00123 std::stringstream msg;
00124 char* sys_error;
00125 char* rods_error = rodsErrorName(srcL1descInx, &sys_error);
00126 msg << __FUNCTION__;
00127 msg << " - Failed to open source object: \"";
00128 msg << srcDataObjInp->objPath;
00129 msg << "\" - ";
00130 msg << rods_error << " " << sys_error;
00131 eirods::log(LOG_ERROR, msg.str());
00132 return srcL1descInx;
00133 }
00134
00135
00136 destDataObjInp->dataSize = L1desc[srcL1descInx].dataSize =
00137 L1desc[srcL1descInx].dataObjInfo->dataSize;
00138
00139 createMode = atoi (L1desc[srcL1descInx].dataObjInfo->dataMode);
00140
00141 if (createMode >= 0100)
00142 destDataObjInp->createMode = createMode;
00143
00144 L1desc[srcL1descInx].oprType = COPY_SRC;
00145
00146 if (L1desc[srcL1descInx].l3descInx <= 2) {
00147
00148 addKeyVal (&destDataObjInp->condInput, NO_OPEN_FLAG_KW, "");
00149 }
00150
00151 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00152 if (destL1descInx == CAT_UNKNOWN_COLLECTION) {
00153
00154 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00155 splitPathByKey (destDataObjInp->objPath, parColl, child, '/');
00156 rsMkCollR (rsComm, "/", parColl);
00157 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00158 }
00159
00160 if (destL1descInx < 0) {
00161 std::stringstream msg;
00162 char* sys_error;
00163 char* rods_error = rodsErrorName(destL1descInx, &sys_error);
00164 msg << __FUNCTION__;
00165 msg << " - Failed to create destination object: \"";
00166 msg << destDataObjInp->objPath;
00167 msg << "\" - ";
00168 msg << rods_error << " " << sys_error;
00169 eirods::log(LOG_ERROR, msg.str());
00170 return (destL1descInx);
00171 }
00172
00173 if (L1desc[destL1descInx].replStatus == NEWLY_CREATED_COPY) {
00174 existFlag = 0;
00175 } else {
00176 existFlag = 1;
00177 }
00178
00179 L1desc[destL1descInx].oprType = COPY_DEST;
00180
00181 L1desc[destL1descInx].srcL1descInx = srcL1descInx;
00182
00183 rstrcpy (L1desc[destL1descInx].dataObjInfo->dataType,
00184
00185 L1desc[srcL1descInx].dataObjInfo->dataType, NAME_LEN);
00186
00187
00188 L1desc[destL1descInx].dataSize =
00189 L1desc[srcL1descInx].dataObjInfo->dataSize;
00190
00191 #if 0
00192 (*transStat)->bytesWritten = L1desc[srcL1descInx].dataObjInfo->dataSize;
00193 #endif
00194 status = _rsDataObjCopy (rsComm, destL1descInx, existFlag, transStat);
00195
00196 #if 0
00197 if (status >= 0) {
00198 (*transStat)->numThreads = destDataObjInp->numThreads;
00199 }
00200 #endif
00201
00202 return (status);
00203 }
00204
00205 int
00206 _rsDataObjCopy (rsComm_t *rsComm, int destL1descInx, int existFlag,
00207 transferStat_t **transStat)
00208 {
00209 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00210 openedDataObjInp_t dataObjCloseInp;
00211 dataObjInfo_t *srcDataObjInfo, *destDataObjInfo;
00212 int srcL1descInx;
00213 int status = 0, status2;
00214
00215 destDataObjInp = L1desc[destL1descInx].dataObjInp;
00216 destDataObjInfo = L1desc[destL1descInx].dataObjInfo;
00217 srcL1descInx = L1desc[destL1descInx].srcL1descInx;
00218
00219 srcDataObjInp = L1desc[srcL1descInx].dataObjInp;
00220 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00221
00222 if( destDataObjInp == NULL ) {
00223 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInp is NULL" );
00224 return -1;
00225 }
00226 if( destDataObjInfo == NULL ) {
00227 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInfo is NULL" );
00228 return -1;
00229 }
00230 if( srcDataObjInp == NULL ) {
00231 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInp is NULL" );
00232 return -1;
00233 }
00234 if( srcDataObjInfo == NULL ) {
00235 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInfo is NULL" );
00236 return -1;
00237 }
00238
00239 if (L1desc[srcL1descInx].l3descInx <= 2) {
00240
00241
00242 status = l3DataCopySingleBuf (rsComm, destL1descInx);
00243
00244
00245 if( status >= 0 &&
00246 existFlag == 0 &&
00247 destDataObjInfo->specColl == NULL &&
00248 L1desc[destL1descInx].remoteZoneHost == NULL) {
00249
00250 status = svrRegDataObj (rsComm, destDataObjInfo);
00251 if (status == CAT_UNKNOWN_COLLECTION) {
00252
00253 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00254 splitPathByKey (destDataObjInfo->objPath, parColl, child, '/');
00255 status = svrRegDataObj (rsComm, destDataObjInfo);
00256 rsMkCollR (rsComm, "/", parColl);
00257 status = svrRegDataObj (rsComm, destDataObjInfo);
00258 }
00259 if (status < 0) {
00260 rodsLog (LOG_NOTICE,
00261 "_rsDataObjCopy: svrRegDataObj for %s failed, status = %d",
00262 destDataObjInfo->objPath, status);
00263 return (status);
00264 }
00265 }
00266
00267 } else {
00268 if( srcDataObjInfo != NULL ) {
00269 destDataObjInp->numThreads = getNumThreads( rsComm, srcDataObjInfo->dataSize, destDataObjInp->numThreads, NULL,
00270 srcDataObjInfo->rescHier, destDataObjInfo->rescHier );
00271
00272 }
00273
00274 srcDataObjInp->numThreads = destDataObjInp->numThreads;
00275 #if 0
00276
00277 if (destDataObjInp->numThreads == 0 &&
00278 srcDataObjInfo->dataSize > MAX_SZ_FOR_SINGLE_BUF) {
00279 destDataObjInp->numThreads = 1;
00280 }
00281 #endif
00282
00283 status = dataObjCopy (rsComm, destL1descInx);
00284 }
00285
00286 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00287 dataObjCloseInp.l1descInx = destL1descInx;
00288 if (status >= 0) {
00289 *transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
00290 memset (*transStat, 0, sizeof (transferStat_t));
00291 (*transStat)->bytesWritten = srcDataObjInfo->dataSize;
00292 (*transStat)->numThreads = destDataObjInp->numThreads;
00293 dataObjCloseInp.bytesWritten = srcDataObjInfo->dataSize;
00294 }
00295
00296 status2 = rsDataObjClose (rsComm, &dataObjCloseInp);
00297
00298 if (status) return (status);
00299 return(status2);
00300 }
00301