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