00001
00002
00003
00004
00005
00006
00007 #include "dataObjPhymv.h"
00008 #include "dataObjRepl.h"
00009 #include "dataObjOpr.h"
00010 #include "rodsLog.h"
00011 #include "objMetaOpr.h"
00012 #include "specColl.h"
00013 #include "reGlobalsExtern.h"
00014 #include "reDefines.h"
00015 #include "reSysDataObjOpr.h"
00016 #include "dataObjCreate.h"
00017 #include "getRemoteZoneResc.h"
00018
00019
00020
00021 #include "eirods_resource_redirect.h"
00022
00023 int
00024 rsDataObjPhymv250 (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00025 transStat_t **transStat)
00026 {
00027 int status;
00028 transferStat_t *transferStat = NULL;
00029
00030 status = rsDataObjPhymv (rsComm, dataObjInp, &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
00042
00043
00044
00045
00046
00047
00048
00049 int
00050 rsDataObjPhymv (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00051 transferStat_t **transStat)
00052 {
00053 int status;
00054 dataObjInfo_t *dataObjInfoHead = NULL;
00055 dataObjInfo_t *oldDataObjInfoHead = NULL;
00056 rescGrpInfo_t *myRescGrpInfo = NULL;
00057 ruleExecInfo_t rei;
00058 int multiCopyFlag;
00059 char *accessPerm;
00060 int remoteFlag;
00061 rodsServerHost_t *rodsServerHost;
00062 specCollCache_t *specCollCache = NULL;
00063
00064 resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
00065 &dataObjInp->condInput);
00066 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
00067 REMOTE_OPEN);
00068
00069 if (remoteFlag < 0) {
00070 return (remoteFlag);
00071 } else if (remoteFlag == REMOTE_HOST) {
00072 status = _rcDataObjPhymv (rodsServerHost->conn, dataObjInp,
00073 transStat);
00074 return status;
00075 }
00076
00077
00078
00079 if( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
00080 std::string hier;
00081 eirods::error ret = eirods::resolve_resource_hierarchy( eirods::EIRODS_OPEN_OPERATION, rsComm,
00082 dataObjInp, hier );
00083 if( !ret.ok() ) {
00084 std::stringstream msg;
00085 msg << __FUNCTION__;
00086 msg <<" :: failed in eirods::resolve_resource_hierarchy for [";
00087 msg << dataObjInp->objPath << "]";
00088 eirods::log( PASSMSG( msg.str(), ret ) );
00089 return ret.code();
00090 }
00091
00092
00093
00094
00095 addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
00096
00097 }
00098
00099 *transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
00100 memset (*transStat, 0, sizeof (transferStat_t));
00101
00102 if (getValByKey (&dataObjInp->condInput, IRODS_ADMIN_KW) != NULL) {
00103 if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
00104 return (CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
00105 }
00106 accessPerm = NULL;
00107 } else {
00108 accessPerm = ACCESS_DELETE_OBJECT;
00109 }
00110
00111
00112 status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
00113 if (status < 0) return status;
00114
00115 initReiWithDataObjInp (&rei, rsComm, dataObjInp);
00116 status = applyRule ("acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI);
00117 if (strcmp (rei.statusStr, MULTI_COPIES_PER_RESC) == 0) {
00118 multiCopyFlag = 1;
00119 } else {
00120 multiCopyFlag = 0;
00121 }
00122
00123
00124 status = getDataObjInfo (rsComm, dataObjInp, &dataObjInfoHead,
00125 accessPerm, 1);
00126
00127 if (status < 0) {
00128 rodsLog (LOG_NOTICE,
00129 "rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath);
00130 return (status);
00131 }
00132
00133 status = resolveInfoForPhymv (&dataObjInfoHead, &oldDataObjInfoHead, &myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag);
00134
00135 if (status < 0) {
00136 freeAllDataObjInfo (dataObjInfoHead);
00137 freeAllDataObjInfo (oldDataObjInfoHead);
00138 freeAllRescGrpInfo (myRescGrpInfo);
00139 if (status == CAT_NO_ROWS_FOUND) {
00140 return (0);
00141 } else {
00142 return (status);
00143 }
00144 }
00145
00146 status = _rsDataObjPhymv (rsComm, dataObjInp, dataObjInfoHead,
00147 myRescGrpInfo, *transStat, multiCopyFlag);
00148
00149 freeAllDataObjInfo (dataObjInfoHead);
00150 freeAllDataObjInfo (oldDataObjInfoHead);
00151 freeAllRescGrpInfo (myRescGrpInfo);
00152
00153 return (status);
00154 }
00155
00156 int
00157 _rsDataObjPhymv (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00158 dataObjInfo_t *srcDataObjInfoHead, rescGrpInfo_t *destRescGrpInfo,
00159 transferStat_t *transStat, int multiCopyFlag)
00160 {
00161 dataObjInfo_t *srcDataObjInfo;
00162 rescGrpInfo_t *tmpRescGrpInfo;
00163 rescInfo_t *tmpRescInfo;
00164 int status;
00165 int savedStatus = 0;
00166
00167 tmpRescGrpInfo = destRescGrpInfo;
00168 srcDataObjInfo = srcDataObjInfoHead;
00169 while (tmpRescGrpInfo != NULL) {
00170 tmpRescInfo = tmpRescGrpInfo->rescInfo;
00171 while (srcDataObjInfo != NULL) {
00172
00173 dataObjInp->oprType = PHYMV_OPR;
00174 status = _rsDataObjReplS (rsComm, dataObjInp, srcDataObjInfo,
00175 tmpRescInfo, tmpRescGrpInfo->rescGroupName, NULL, 0);
00176
00177 if (multiCopyFlag == 0) {
00178 if (status >= 0) {
00179 srcDataObjInfo = srcDataObjInfo->next;
00180 } else {
00181 savedStatus = status;
00182 }
00183
00184 break;
00185 } else {
00186 if (status < 0) {
00187 savedStatus = status;
00188
00189 break;
00190 }
00191 }
00192 srcDataObjInfo = srcDataObjInfo->next;
00193 }
00194 if (status >= 0)
00195 transStat->numThreads = dataObjInp->numThreads;
00196 tmpRescGrpInfo = tmpRescGrpInfo->next;
00197 }
00198
00199 if (srcDataObjInfo != NULL) {
00200
00201 if (savedStatus == 0) {
00202 status = SYS_COPY_ALREADY_IN_RESC;
00203 }
00204 } else {
00205 savedStatus = 0;
00206 }
00207
00208 return (savedStatus);
00209 }
00210