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 int
00020 rsDataObjCopy250 (rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
00021 transStat_t **transStat)
00022 {
00023 int status;
00024 transferStat_t *transferStat = NULL;
00025
00026 status = rsDataObjCopy (rsComm, dataObjCopyInp, &transferStat);
00027
00028 if (transStat != NULL && status >= 0 && transferStat != NULL) {
00029 *transStat = (transStat_t *) malloc (sizeof (transStat_t));
00030 (*transStat)->numThreads = transferStat->numThreads;
00031 (*transStat)->bytesWritten = transferStat->bytesWritten;
00032 free (transferStat);
00033 }
00034 return status;
00035 }
00036
00037 int
00038 rsDataObjCopy (rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
00039 transferStat_t **transStat)
00040 {
00041 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00042 int srcL1descInx, destL1descInx;
00043 int status;
00044 int existFlag;
00045 uint createMode;
00046 int remoteFlag;
00047 rodsServerHost_t *rodsServerHost;
00048 specCollCache_t *specCollCache = NULL;
00049
00050 srcDataObjInp = &dataObjCopyInp->srcDataObjInp;
00051 destDataObjInp = &dataObjCopyInp->destDataObjInp;
00052
00053 resolveLinkedPath (rsComm, srcDataObjInp->objPath, &specCollCache,
00054 &srcDataObjInp->condInput);
00055 resolveLinkedPath (rsComm, destDataObjInp->objPath, &specCollCache,
00056 &destDataObjInp->condInput);
00057 remoteFlag = getAndConnRemoteZoneForCopy (rsComm, dataObjCopyInp,
00058 &rodsServerHost);
00059
00060 if (remoteFlag < 0) {
00061 return (remoteFlag);
00062 } else if (remoteFlag == REMOTE_HOST) {
00063 status = _rcDataObjCopy (rodsServerHost->conn, dataObjCopyInp,
00064 transStat);
00065 return status;
00066 }
00067
00068 #if 0
00069 *transStat = malloc (sizeof (transferStat_t));
00070 memset (*transStat, 0, sizeof (transferStat_t));
00071 #endif
00072
00073 if (strcmp (srcDataObjInp->objPath, destDataObjInp->objPath) == 0) {
00074 rodsLog (LOG_ERROR,
00075 "rsDataObjCopy: same src and dest objPath %s not allowed",
00076 srcDataObjInp->objPath);
00077 return (USER_INPUT_PATH_ERR);
00078 }
00079
00080 addKeyVal (&srcDataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "");
00081 srcL1descInx = rsDataObjOpen (rsComm, srcDataObjInp);
00082
00083 if (srcL1descInx < 0)
00084 return srcL1descInx;
00085
00086
00087 destDataObjInp->dataSize = L1desc[srcL1descInx].dataSize =
00088 L1desc[srcL1descInx].dataObjInfo->dataSize;
00089
00090 createMode = atoi (L1desc[srcL1descInx].dataObjInfo->dataMode);
00091 if (createMode >= 0100)
00092 destDataObjInp->createMode = createMode;
00093 L1desc[srcL1descInx].oprType = COPY_SRC;
00094
00095 if (L1desc[srcL1descInx].l3descInx <= 2) {
00096
00097 addKeyVal (&destDataObjInp->condInput, NO_OPEN_FLAG_KW, "");
00098 }
00099
00100 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00101 if (destL1descInx == CAT_UNKNOWN_COLLECTION) {
00102
00103 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00104 splitPathByKey (destDataObjInp->objPath, parColl, child, '/');
00105 rsMkCollR (rsComm, "/", parColl);
00106 destL1descInx = rsDataObjCreate (rsComm, destDataObjInp);
00107 }
00108
00109 if (destL1descInx < 0) {
00110 return (destL1descInx);
00111 }
00112
00113 if (L1desc[destL1descInx].replStatus == NEWLY_CREATED_COPY) {
00114 existFlag = 0;
00115 } else {
00116 existFlag = 1;
00117 }
00118
00119 L1desc[destL1descInx].oprType = COPY_DEST;
00120
00121 L1desc[destL1descInx].srcL1descInx = srcL1descInx;
00122
00123 rstrcpy (L1desc[destL1descInx].dataObjInfo->dataType,
00124
00125 L1desc[srcL1descInx].dataObjInfo->dataType, NAME_LEN);
00126
00127
00128 L1desc[destL1descInx].dataSize =
00129 L1desc[srcL1descInx].dataObjInfo->dataSize;
00130
00131 #if 0
00132 (*transStat)->bytesWritten = L1desc[srcL1descInx].dataObjInfo->dataSize;
00133 #endif
00134
00135 status = _rsDataObjCopy (rsComm, destL1descInx, existFlag, transStat);
00136
00137 #if 0
00138 if (status >= 0) {
00139 (*transStat)->numThreads = destDataObjInp->numThreads;
00140 }
00141 #endif
00142
00143 return (status);
00144 }
00145
00146 int
00147 _rsDataObjCopy (rsComm_t *rsComm, int destL1descInx, int existFlag,
00148 transferStat_t **transStat)
00149 {
00150 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00151 openedDataObjInp_t dataObjCloseInp;
00152 dataObjInfo_t *srcDataObjInfo, *destDataObjInfo;
00153 int srcL1descInx;
00154 int status, status2;
00155 char *destRescName, *srcRescName;
00156
00157 destDataObjInp = L1desc[destL1descInx].dataObjInp;
00158 destDataObjInfo = L1desc[destL1descInx].dataObjInfo;
00159 srcL1descInx = L1desc[destL1descInx].srcL1descInx;
00160
00161 srcDataObjInp = L1desc[srcL1descInx].dataObjInp;
00162 srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
00163
00164 if( destDataObjInp == NULL ) {
00165 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInp is NULL" );
00166 return -1;
00167 }
00168 if( destDataObjInfo == NULL ) {
00169 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInfo is NULL" );
00170 return -1;
00171 }
00172 if( srcDataObjInp == NULL ) {
00173 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInp is NULL" );
00174 return -1;
00175 }
00176 if( srcDataObjInfo == NULL ) {
00177 rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInfo is NULL" );
00178 return -1;
00179 }
00180
00181 if (L1desc[srcL1descInx].l3descInx <= 2) {
00182
00183 status = l3DataCopySingleBuf (rsComm, destL1descInx);
00184
00185 if (status >= 0 && existFlag == 0 &&
00186 destDataObjInfo->specColl == NULL &&
00187 L1desc[destL1descInx].remoteZoneHost == NULL) {
00188
00189
00190 status = svrRegDataObj (rsComm, destDataObjInfo);
00191 if (status == CAT_UNKNOWN_COLLECTION) {
00192
00193 char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
00194 splitPathByKey (destDataObjInfo->objPath, parColl, child, '/');
00195 rsMkCollR (rsComm, "/", parColl);
00196 status = svrRegDataObj (rsComm, destDataObjInfo);
00197 }
00198 if (status < 0) {
00199 rodsLog (LOG_NOTICE,
00200 "_rsDataObjCopy: svrRegDataObj for %s failed, status = %d",
00201 destDataObjInfo->objPath, status);
00202 return (status);
00203 }
00204 }
00205 } else {
00206 if (destDataObjInfo != NULL && destDataObjInfo->rescInfo != NULL)
00207 destRescName = destDataObjInfo->rescInfo->rescName;
00208 else
00209 destRescName = NULL;
00210
00211 if (srcDataObjInfo != NULL && srcDataObjInfo->rescInfo != NULL)
00212 srcRescName = srcDataObjInfo->rescInfo->rescName;
00213 else
00214 srcRescName = NULL;
00215
00216 if( srcDataObjInfo != NULL )
00217 destDataObjInp->numThreads = getNumThreads( rsComm, srcDataObjInfo->dataSize, destDataObjInp->numThreads, NULL,destRescName, srcRescName);
00218
00219 srcDataObjInp->numThreads = destDataObjInp->numThreads;
00220 #if 0
00221
00222 if (destDataObjInp->numThreads == 0 &&
00223 srcDataObjInfo->dataSize > MAX_SZ_FOR_SINGLE_BUF) {
00224 destDataObjInp->numThreads = 1;
00225 }
00226 #endif
00227 status = dataObjCopy (rsComm, destL1descInx);
00228 }
00229
00230 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00231
00232 dataObjCloseInp.l1descInx = destL1descInx;
00233 if (status >= 0) {
00234 *transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
00235 memset (*transStat, 0, sizeof (transferStat_t));
00236 (*transStat)->bytesWritten = srcDataObjInfo->dataSize;
00237 (*transStat)->numThreads = destDataObjInp->numThreads;
00238 dataObjCloseInp.bytesWritten = srcDataObjInfo->dataSize;
00239 }
00240
00241 status2 = rsDataObjClose (rsComm, &dataObjCloseInp);
00242
00243 if (status) return (status);
00244 return(status2);
00245 }
00246