int
getAndConnRemoteZoneForCopy( rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
rodsServerHost_t **rodsServerHost ) {
int status;
dataObjInp_t *srcDataObjInp, *destDataObjInp;
rodsServerHost_t *srcIcatServerHost = NULL;
rodsServerHost_t *destIcatServerHost = NULL;
srcDataObjInp = &dataObjCopyInp->srcDataObjInp;
destDataObjInp = &dataObjCopyInp->destDataObjInp;
status = getRcatHost( MASTER_RCAT, srcDataObjInp->objPath,
&srcIcatServerHost );
if ( status < 0 || NULL == srcIcatServerHost ) { // JMC cppcheck - nullptr
rodsLog( LOG_ERROR,
"getAndConnRemoteZoneForCopy: getRcatHost error for %s",
srcDataObjInp->objPath );
return status;
}
if ( srcIcatServerHost->rcatEnabled != REMOTE_ICAT ) {
/* local zone. nothing to do */
return LOCAL_HOST;
}
status = getRcatHost( MASTER_RCAT, destDataObjInp->objPath,
&destIcatServerHost );
if ( status < 0 || NULL == destIcatServerHost ) { // JMC cppcheck - nullptr
rodsLog( LOG_ERROR,
"getAndConnRemoteZoneForCopy: getRcatHost error for %s",
destDataObjInp->objPath );
return status;
}
if ( destIcatServerHost->rcatEnabled != REMOTE_ICAT ) {
/* local zone. nothing to do */
return LOCAL_HOST;
}
/* remote zone to different remote zone copy. Have to handle it
* locally because of proxy admin user privilege issue */
if ( srcIcatServerHost != destIcatServerHost ) {
return LOCAL_HOST;
}
/* from the same remote zone. do it in the remote zone */
status = getAndConnRemoteZone( rsComm, destDataObjInp, rodsServerHost,
REMOTE_CREATE );
return status;
}
int
rsDataObjGet (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf)
{
int status;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == LOCAL_HOST) {
status = _rsDataObjGet (rsComm, dataObjInp, portalOprOut,
dataObjOutBBuf, BRANCH_MSG);
} else {
int l1descInx;
status = _rcDataObjGet (rodsServerHost->conn, dataObjInp, portalOprOut,
dataObjOutBBuf);
if (status < 0) {
return (status);
}
if (status == 0 ||
(dataObjOutBBuf != NULL && dataObjOutBBuf->len > 0)) {
/* data included in buf */
return status;
} else {
/* have to allocate a local l1descInx to keep track of things
* since the file is in remote zone. It sets remoteL1descInx,
* oprType = REMOTE_ZONE_OPR and remoteZoneHost so that
* rsComplete knows what to do */
l1descInx = allocAndSetL1descForZoneOpr (
(*portalOprOut)->l1descInx, dataObjInp, rodsServerHost, NULL);
if (l1descInx < 0) return l1descInx;
(*portalOprOut)->l1descInx = l1descInx;
return status;
}
}
return (status);
}
int
rsSyncMountedColl (rsComm_t *rsComm, dataObjInp_t *syncMountedCollInp)
{
int status;
rodsObjStat_t *rodsObjStatOut = NULL;
dataObjInp_t myDataObjInp;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
status = collStat (rsComm, syncMountedCollInp, &rodsObjStatOut);
if (status < 0) return status;
if (rodsObjStatOut->specColl == NULL) {
freeRodsObjStat (rodsObjStatOut);
rodsLog (LOG_ERROR,
"rsSyncMountedColl: %s not a mounted collection",
syncMountedCollInp->objPath);
return (SYS_COLL_NOT_MOUNTED_ERR);
}
bzero (&myDataObjInp, sizeof (myDataObjInp));
rstrcpy (myDataObjInp.objPath, rodsObjStatOut->specColl->objPath,
MAX_NAME_LEN);
remoteFlag = getAndConnRemoteZone (rsComm, &myDataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = rcSyncMountedColl (rodsServerHost->conn,
syncMountedCollInp);
} else {
status = _rsSyncMountedColl (rsComm, rodsObjStatOut->specColl,
syncMountedCollInp->oprType);
}
freeRodsObjStat (rodsObjStatOut);
return (status);
}
int
rsDataObjPhymv( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat ) {
int status = 0;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag = 0;
char *accessPerm = NULL;
int remoteFlag = 0;
rodsServerHost_t *rodsServerHost = NULL;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = _rcDataObjPhymv( rodsServerHost->conn, dataObjInp,
transStat );
return status;
}
// =-=-=-=-=-=-=-
// determine hierarchy string
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
*transStat = ( transferStat_t* )malloc( sizeof( transferStat_t ) );
memset( *transStat, 0, sizeof( transferStat_t ) );
if ( getValByKey( &dataObjInp->condInput, ADMIN_KW ) != NULL ) {
if ( rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH ) {
return CAT_INSUFFICIENT_PRIVILEGE_LEVEL;
}
accessPerm = NULL;
}
else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
status = applyRule( "acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI );
if ( strcmp( rei.statusStr, MULTI_COPIES_PER_RESC ) == 0 ) {
multiCopyFlag = 1;
}
else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo( rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1 );
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath );
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
status = resolveInfoForPhymv( &dataObjInfoHead, &oldDataObjInfoHead, &myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag );
if ( status < 0 ) {
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
if ( status == CAT_NO_ROWS_FOUND ) {
return 0;
}
else {
return status;
}
}
status = _rsDataObjPhymv( rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag );
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
return status;
}
int
rsDataObjCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) {
int l1descInx;
int status;
rodsObjStat_t *rodsObjStatOut = NULL;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
char *lockType = NULL; // JMC - backport 4604
int lockFd = -1; // JMC - backport 4604
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_CREATE );
if ( remoteFlag < 0 ) {
return ( remoteFlag );
}
else if ( remoteFlag == REMOTE_HOST ) {
openStat_t *openStat = NULL;
addKeyVal( &dataObjInp->condInput, CROSS_ZONE_CREATE_KW, "" );
status = rcDataObjCreateAndStat( rodsServerHost->conn, dataObjInp, &openStat );
/* rm it to avoid confusion */
rmKeyVal( &dataObjInp->condInput, CROSS_ZONE_CREATE_KW );
if ( status < 0 ) {
return status;
}
l1descInx = allocAndSetL1descForZoneOpr( status, dataObjInp, rodsServerHost, openStat );
if ( openStat != NULL ) {
free( openStat );
}
return ( l1descInx );
}
// =-=-=-=-=-=-=-
// working on the "home zone", determine if we need to redirect to a different
// server in this zone for this operation. if there is a RESC_HIER_STR_KW then
// we know that the redirection decision has already been made
char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
if ( NULL == resc_hier ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::CREATE_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << "failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
// =-=-=-=-=-=-=-
// JMC - backport 4604
lockType = getValByKey( &dataObjInp->condInput, LOCK_TYPE_KW );
if ( lockType != NULL ) {
lockFd = rsDataObjLock( rsComm, dataObjInp );
if ( lockFd >= 0 ) {
/* rm it so it won't be done again causing deadlock */
rmKeyVal( &dataObjInp->condInput, LOCK_TYPE_KW );
}
else {
rodsLogError( LOG_ERROR, lockFd,
"rsDataObjCreate: rsDataObjLock error for %s. lockType = %s",
dataObjInp->objPath, lockType );
return lockFd;
}
}
// =-=-=-=-=-=-=-
// Gets here means local zone operation stat dataObj
addKeyVal( &dataObjInp->condInput, SEL_OBJ_TYPE_KW, "dataObj" );
status = rsObjStat( rsComm, dataObjInp, &rodsObjStatOut );
if ( rodsObjStatOut != NULL && rodsObjStatOut->objType == COLL_OBJ_T ) {
if ( lockFd >= 0 ) {
rsDataObjUnlock( rsComm, dataObjInp, lockFd ); // JMC - backport 4604
}
return ( USER_INPUT_PATH_ERR );
}
if ( rodsObjStatOut != NULL &&
rodsObjStatOut->specColl != NULL &&
rodsObjStatOut->specColl->collClass == LINKED_COLL ) {
/* should not be here because if has been translated */
if ( lockFd >= 0 ) {
rsDataObjUnlock( rsComm, dataObjInp, lockFd ); // JMC - backport 4604
}
return SYS_COLL_LINK_PATH_ERR;
}
if ( rodsObjStatOut == NULL ||
( rodsObjStatOut->objType == UNKNOWN_OBJ_T &&
rodsObjStatOut->specColl == NULL ) ) {
/* does not exist. have to create one */
/* use L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY instead */
/* newly created. take out FORCE_FLAG since it could be used by put */
/* rmKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW); */
l1descInx = _rsDataObjCreate( rsComm, dataObjInp );
}
else if ( rodsObjStatOut->specColl != NULL &&
rodsObjStatOut->objType == UNKNOWN_OBJ_T ) {
/* newly created. take out FORCE_FLAG since it could be used by put */
/* rmKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW); */
l1descInx = specCollSubCreate( rsComm, dataObjInp );
}
else {
/* dataObj exist */
if ( getValByKey( &dataObjInp->condInput, FORCE_FLAG_KW ) != NULL ) {
dataObjInp->openFlags |= O_TRUNC | O_RDWR;
// =-=-=-=-=-=-=-
// re-determine the resource hierarchy since this is an open instead of a create
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::WRITE_OPERATION,
rsComm, dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
std::string top_resc;
irods::hierarchy_parser parser;
parser.set_string( hier );
parser.first_resc( top_resc );
addKeyVal( &dataObjInp->condInput, DEST_RESC_NAME_KW, top_resc.c_str() );
l1descInx = _rsDataObjOpen( rsComm, dataObjInp );
}
else {
l1descInx = OVERWRITE_WITHOUT_FORCE_FLAG;
}
}
if ( rodsObjStatOut != NULL ) {
freeRodsObjStat( rodsObjStatOut );
}
// =-=-=-=-=-=-=-
// JMC - backport 4604
if ( lockFd >= 0 ) {
if ( l1descInx >= 0 ) {
L1desc[l1descInx].lockFd = lockFd;
}
else {
rsDataObjUnlock( rsComm, dataObjInp, lockFd );
}
}
// =-=-=-=-=-=-=-
return ( l1descInx );
}
int
rsDataObjOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) {
int status, l1descInx;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
openStat_t *openStat = NULL;
status = rcDataObjOpenAndStat( rodsServerHost->conn, dataObjInp,
&openStat );
if ( status < 0 ) {
return status;
}
l1descInx = allocAndSetL1descForZoneOpr( status, dataObjInp,
rodsServerHost, openStat );
if ( openStat != NULL ) {
free( openStat );
}
return l1descInx;
}
else {
// dataObjInfo_t linked list
dataObjInfo_t *dataObjInfoHead = NULL;
// resource hierarchy
std::string hier;
// =-=-=-=-=-=-=-
// determine the resource hierarchy if one is not provided
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
irods::error ret = irods::resolve_resource_hierarchy(
irods::OPEN_OPERATION,
rsComm,
dataObjInp,
hier,
&dataObjInfoHead );
if (ret.ok()) {
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
}
}
else {
// file object for file_object_factory
irods::file_object_ptr file_obj( new irods::file_object() );
// get resource hierarchy from condInput
hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
// get replicas vector populated
irods::error fac_err = irods::file_object_factory(rsComm, dataObjInp, file_obj, &dataObjInfoHead);
}// if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL )
l1descInx = _rsDataObjOpen( rsComm, dataObjInp, dataObjInfoHead );
}
return l1descInx;
}
int
rsStructFileBundle( rsComm_t *rsComm,
structFileExtAndRegInp_t *structFileBundleInp ) {
int status;
rodsServerHost_t *rodsServerHost;
int remoteFlag;
dataObjInp_t dataObjInp;
memset( &dataObjInp, 0, sizeof( dataObjInp ) );
rstrcpy( dataObjInp.objPath, structFileBundleInp->objPath,
MAX_NAME_LEN );
remoteFlag = getAndConnRemoteZone( rsComm, &dataObjInp, &rodsServerHost,
REMOTE_CREATE );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = rcStructFileBundle( rodsServerHost->conn,
structFileBundleInp );
return status;
}
// =-=-=-=-=-=-=-
// working on the "home zone", determine if we need to redirect to a different
// server in this zone for this operation. if there is a RESC_HIER_STR_KW then
// we know that the redirection decision has already been made
std::string hier;
int local = LOCAL_HOST;
rodsServerHost_t* host = 0;
dataObjInp_t data_inp;
bzero( &data_inp, sizeof( data_inp ) );
rstrcpy( data_inp.objPath, structFileBundleInp->objPath, MAX_NAME_LEN );
copyKeyValPairStruct( &structFileBundleInp->condInput, &data_inp.condInput );
if ( getValByKey( &structFileBundleInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
irods::error ret = irods::resource_redirect( irods::CREATE_OPERATION, rsComm,
&data_inp, hier, host, local );
if ( !ret.ok() ) {
std::stringstream msg;
msg << "rsStructFileBundle :: failed in irods::resource_redirect for [";
msg << &data_inp.objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &structFileBundleInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
if ( LOCAL_HOST == local ) {
status = _rsStructFileBundle( rsComm, structFileBundleInp );
}
else {
status = rcStructFileBundle( host->conn, structFileBundleInp );
} // else remote host
return status;
}
int
rsDataObjPut (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut)
{
int status;
int status2;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
#if 0
status = resolvePathInSpecColl (rsComm, dataObjInp->objPath,
READ_COLL_PERM, 0, &dataObjInfo);
if (dataObjInfo != NULL) {
if (dataObjInfo->specColl != NULL &&
dataObjInfo->specColl->collClass == LINKED_COLL) {
rstrcpy (dataObjInp->objPath, dataObjInfo->objPath,
MAX_NAME_LEN);
}
freeAllDataObjInfo (dataObjInfo);
}
#endif
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
REMOTE_CREATE);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == LOCAL_HOST) {
/** since the object is written here, we apply pre procesing RAJA
* Dec 2 2010 **/
status2 = applyRuleForPostProcForWrite(rsComm, dataObjInpBBuf,
dataObjInp->objPath);
if (status2 < 0)
return(status2); /* need to dealloc anything??? */
/** since the object is written here, we apply pre procesing RAJA
* Dec 2 2010 **/
dataObjInp->openFlags = O_RDWR;
status = _rsDataObjPut (rsComm, dataObjInp, dataObjInpBBuf,
portalOprOut, BRANCH_MSG);
} else {
int l1descInx;
status = _rcDataObjPut (rodsServerHost->conn, dataObjInp,
dataObjInpBBuf, portalOprOut);
if (status < 0 ||
getValByKey (&dataObjInp->condInput, DATA_INCLUDED_KW) != NULL) {
return (status);
} else {
/* have to allocate a local l1descInx to keep track of things
* since the file is in remote zone. It sets remoteL1descInx,
* oprType = REMOTE_ZONE_OPR and remoteZoneHost so that
* rsComplete knows what to do */
l1descInx = allocAndSetL1descForZoneOpr (
(*portalOprOut)->l1descInx, dataObjInp, rodsServerHost, NULL);
if (l1descInx < 0) return l1descInx;
(*portalOprOut)->l1descInx = l1descInx;
return status;
}
}
return (status);
}
int
rsDataObjGet( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf ) {
int status;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == LOCAL_HOST ) {
// =-=-=-=-=-=-=-
// working on the "home zone", determine if we need to redirect to a different
// server in this zone for this operation. if there is a RESC_HIER_STR_KW then
// we know that the redirection decision has already been made
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << "rsDataObjGet :: failed in irods::resolve_resource_redirect for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
status = _rsDataObjGet( rsComm, dataObjInp, portalOprOut, dataObjOutBBuf, BRANCH_MSG );
}
else {
int l1descInx;
status = _rcDataObjGet( rodsServerHost->conn, dataObjInp, portalOprOut,
dataObjOutBBuf );
if ( status < 0 ) {
return status;
}
if ( status == 0 ||
( dataObjOutBBuf != NULL && dataObjOutBBuf->len > 0 ) ) {
/* data included in buf */
return status;
}
else {
/* have to allocate a local l1descInx to keep track of things
* since the file is in remote zone. It sets remoteL1descInx,
* oprType = REMOTE_ZONE_OPR and remoteZoneHost so that
* rsComplete knows what to do */
l1descInx = allocAndSetL1descForZoneOpr(
( *portalOprOut )->l1descInx, dataObjInp, rodsServerHost, NULL );
if ( l1descInx < 0 ) {
return l1descInx;
}
( *portalOprOut )->l1descInx = l1descInx;
return status;
}
}
return status;
}
int
rsDataObjPhymv (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat)
{
int status;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag;
char *accessPerm;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = _rcDataObjPhymv (rodsServerHost->conn, dataObjInp,
transStat);
return status;
}
*transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
memset (*transStat, 0, sizeof (transferStat_t));
if (getValByKey (&dataObjInp->condInput, IRODS_ADMIN_KW) != NULL) {
if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
return (CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
}
accessPerm = NULL;
} else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
if (status < 0) return status;
initReiWithDataObjInp (&rei, rsComm, dataObjInp);
status = applyRule ("acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI);
if (strcmp (rei.statusStr, MULTI_COPIES_PER_RESC) == 0) {
multiCopyFlag = 1;
} else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo (rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1);
if (status < 0) {
rodsLog (LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath);
return (status);
}
status = resolveInfoForPhymv (&dataObjInfoHead, &oldDataObjInfoHead,
&myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag);
if (status < 0) {
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
if (status == CAT_NO_ROWS_FOUND) {
return (0);
} else {
return (status);
}
}
status = _rsDataObjPhymv (rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag);
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
return (status);
}
int
rsDataObjRsync (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
msParamArray_t **outParamArray)
{
int status;
char *rsyncMode;
char *remoteZoneOpr;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
*outParamArray = NULL;
if (dataObjInp == NULL) {
rodsLog(LOG_ERROR, "rsDataObjRsync error. NULL input");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
rsyncMode = getValByKey (&dataObjInp->condInput, RSYNC_MODE_KW);
if (rsyncMode == NULL) {
rodsLog (LOG_ERROR,
"rsDataObjRsync: RSYNC_MODE_KW input is missing");
return (USER_RSYNC_NO_MODE_INPUT_ERR);
}
if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) {
remoteZoneOpr = REMOTE_CREATE;
} else {
remoteZoneOpr = REMOTE_OPEN;
}
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) {
if (isLocalZone (dataObjInp->objPath) == 0) {
dataObjInp_t myDataObjInp;
char *destObjPath;
/* source in a remote zone. try dest */
destObjPath = getValByKey (&dataObjInp->condInput,
RSYNC_DEST_PATH_KW);
if (destObjPath == NULL) {
rodsLog (LOG_ERROR,
"rsDataObjRsync: RSYNC_DEST_PATH_KW input is missing for %s",
dataObjInp->objPath);
return (USER_RSYNC_NO_MODE_INPUT_ERR);
}
myDataObjInp = *dataObjInp;
remoteZoneOpr = REMOTE_CREATE;
rstrcpy (myDataObjInp.objPath, destObjPath, MAX_NAME_LEN);
remoteFlag = getAndConnRemoteZone (rsComm, &myDataObjInp,
&rodsServerHost, remoteZoneOpr);
} else {
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp,
&rodsServerHost, remoteZoneOpr);
}
} else {
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
remoteZoneOpr);
}
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = _rcDataObjRsync (rodsServerHost->conn, dataObjInp,
outParamArray);
#if 0
int l1descInx;
if (status < 0) {
return (status);
}
if (status == SYS_SVR_TO_CLI_MSI_REQUEST) {
/* server request to client */
l1descInx = allocAndSetL1descForZoneOpr (0, dataObjInp,
rodsServerHost, NULL);
if (l1descInx < 0) return l1descInx;
if (*outParamArray == NULL) {
*outParamArray = malloc (sizeof (msParamArray_t));
bzero (*outParamArray, sizeof (msParamArray_t));
}
addIntParamToArray (*outParamArray, CL_ZONE_OPR_INX, l1descInx);
}
#endif
return status;
}
if (strcmp (rsyncMode, IRODS_TO_LOCAL) == 0) {
status = rsRsyncFileToData (rsComm, dataObjInp);
} else if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) {
status = rsRsyncDataToFile (rsComm, dataObjInp);
} else if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) {
status = rsRsyncDataToData (rsComm, dataObjInp);
} else {
rodsLog (LOG_ERROR,
"rsDataObjRsync: rsyncMode %s not supported");
return (USER_RSYNC_NO_MODE_INPUT_ERR);
}
return (status);
}
int
rsStructFileBundle (rsComm_t *rsComm,
structFileExtAndRegInp_t *structFileBundleInp)
{
#if 0
char *destRescName = NULL;
#endif
int status;
rodsServerHost_t *rodsServerHost;
int remoteFlag;
rodsHostAddr_t rescAddr;
dataObjInp_t dataObjInp;
rescGrpInfo_t *rescGrpInfo = NULL;
memset (&dataObjInp, 0, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, structFileBundleInp->objPath,
MAX_NAME_LEN);
remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost,
REMOTE_CREATE);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = rcStructFileBundle (rodsServerHost->conn,
structFileBundleInp);
return status;
}
#if 0
if ((destRescName =
getValByKey (&structFileBundleInp->condInput, DEST_RESC_NAME_KW)) == NULL
&& (destRescName =
getValByKey (&structFileBundleInp->condInput, DEF_RESC_NAME_KW)) == NULL) {
return USER_NO_RESC_INPUT_ERR;
}
status = _getRescInfo (rsComm, destRescName, &rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"rsStructFileBundle: _getRescInfo of %s error for %s. stat = %d",
destRescName, structFileBundleInp->collection, status);
return status;
}
#else
/* borrow conInput */
dataObjInp.condInput = structFileBundleInp->condInput;
status = getRescGrpForCreate (rsComm, &dataObjInp, &rescGrpInfo);
if (status < 0) return status;
#endif
bzero (&rescAddr, sizeof (rescAddr));
rstrcpy (rescAddr.hostAddr, rescGrpInfo->rescInfo->rescLoc, NAME_LEN);
remoteFlag = resolveHost (&rescAddr, &rodsServerHost);
if (remoteFlag == LOCAL_HOST) {
status = _rsStructFileBundle (rsComm, structFileBundleInp);
} else if (remoteFlag == REMOTE_HOST) {
status = remoteStructFileBundle (rsComm, structFileBundleInp,
rodsServerHost);
} else if (remoteFlag < 0) {
status = remoteFlag;
}
freeAllRescGrpInfo (rescGrpInfo);
return status;
}
int
rsNcCreate( rsComm_t *rsComm, ncOpenInp_t *ncCreateInp, int **ncid ) {
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
int status;
dataObjInp_t dataObjInp;
int l1descInx, myncid;
if ( getValByKey( &ncCreateInp->condInput, NATIVE_NETCDF_CALL_KW ) != NULL ) {
/* just do nc_open with objPath as file nc file path */
/* must to be called internally */
if ( rsComm->proxyUser.authInfo.authFlag < REMOTE_PRIV_USER_AUTH ) {
return( CAT_INSUFFICIENT_PRIVILEGE_LEVEL );
}
status = nc_create( ncCreateInp->objPath, ncCreateInp->mode, &myncid );
if ( status == NC_NOERR ) {
*ncid = ( int * ) malloc( sizeof( int ) );
*( *ncid ) = myncid;
return 0;
}
else {
rodsLog( LOG_ERROR,
"rsNccreate: nc_create %s error, status = %d, %s",
ncCreateInp->objPath, status, nc_strerror( status ) );
return ( NETCDF_OPEN_ERR + status );
}
}
bzero( &dataObjInp, sizeof( dataObjInp ) );
rstrcpy( dataObjInp.objPath, ncCreateInp->objPath, MAX_NAME_LEN );
replKeyVal( &ncCreateInp->condInput, &dataObjInp.condInput );
resolveLinkedPath( rsComm, dataObjInp.objPath, &specCollCache,
&dataObjInp.condInput );
remoteFlag = getAndConnRemoteZone( rsComm, &dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return ( remoteFlag );
}
else if ( remoteFlag == LOCAL_HOST ) {
addKeyVal( &dataObjInp.condInput, NO_OPEN_FLAG_KW, "" );
l1descInx = _rsDataObjCreate( rsComm, &dataObjInp );
clearKeyVal( &dataObjInp.condInput );
if ( l1descInx < 0 ) {
return l1descInx;
}
l1desc_t& my_desc = irods::get_l1desc( l1descInx );
remoteFlag = resoAndConnHostByDataObjInfo( rsComm,
my_desc.dataObjInfo, &rodsServerHost );
if ( remoteFlag < 0 ) {
return ( remoteFlag );
}
else if ( remoteFlag == LOCAL_HOST ) {
status = nc_create( my_desc.dataObjInfo->filePath,
ncCreateInp->mode, &myncid );
if ( status != NC_NOERR ) {
rodsLog( LOG_ERROR,
"rsNcCreate: nc_open %s error, status = %d, %s",
ncCreateInp->objPath, status, nc_strerror( status ) );
freeL1desc( l1descInx );
return ( NETCDF_CREATE_ERR + status );
}
}
else {
/* execute it remotely with dataObjInfo->filePath */
ncOpenInp_t myNcCreateInp;
bzero( &myNcCreateInp, sizeof( myNcCreateInp ) );
rstrcpy( myNcCreateInp.objPath,
my_desc.dataObjInfo->filePath, MAX_NAME_LEN );
addKeyVal( &myNcCreateInp.condInput, NATIVE_NETCDF_CALL_KW, "" );
status = rcNcCreate( rodsServerHost->conn, &myNcCreateInp, &myncid );
clearKeyVal( &myNcCreateInp.condInput );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"rsNcCreate: _rcNcCreate %s error, status = %d",
myNcCreateInp.objPath, status );
freeL1desc( l1descInx );
return ( status );
}
}
my_desc.l3descInx = myncid;
/* need to reg here since NO_OPEN_FLAG_KW does not do it */
if ( my_desc.dataObjInfo->specColl == NULL ) {
status = svrRegDataObj( rsComm, my_desc.dataObjInfo );
if ( status < 0 ) {
ncCloseInp_t myNcCloseInp;
bzero( &myNcCloseInp, sizeof( myNcCloseInp ) );
myNcCloseInp.ncid = l1descInx;
irods::server_api_call ( NC_CLOSE_AN, rsComm, &myNcCloseInp );
l3Unlink( rsComm, my_desc.dataObjInfo );
rodsLog( LOG_ERROR,
"rsNcCreate: svrRegDataObj for %s failed, status = %d",
my_desc.dataObjInfo->objPath, status );
freeL1desc( l1descInx );
return ( NETCDF_CREATE_ERR + status );
}
}
}
else {
addKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW, "" );
status = rcNcCreate( rodsServerHost->conn, ncCreateInp, &myncid );
/* rm it to avoid confusion */
rmKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"rsNcCreate: _rcNcCreate %s error, status = %d",
ncCreateInp->objPath, status );
return ( status );
}
l1descInx = allocAndSetL1descForZoneOpr( myncid, &dataObjInp,
rodsServerHost, NULL );
}
l1desc_t& my_desc = irods::get_l1desc( l1descInx );
my_desc.oprType = NC_CREATE;
*ncid = ( int * ) malloc( sizeof( int ) );
*( *ncid ) = l1descInx;
return 0;
}
int
rsDataObjPut( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut ) {
int status;
int status2;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_CREATE );
if ( const char* acl_string = getValByKey( &dataObjInp->condInput, ACL_INCLUDED_KW ) ) {
try {
irods::deserialize_acl( acl_string );
}
catch ( const irods::exception& e ) {
rodsLog( LOG_ERROR, "%s", e.what() );
return e.code();
}
}
if ( const char* metadata_string = getValByKey( &dataObjInp->condInput, METADATA_INCLUDED_KW ) ) {
try {
irods::deserialize_metadata( metadata_string );
}
catch ( const irods::exception& e ) {
rodsLog( LOG_ERROR, "%s", e.what() );
return e.code();
}
}
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == LOCAL_HOST ) {
// =-=-=-=-=-=-=-
// working on the "home zone", determine if we need to redirect to a different
// server in this zone for this operation. if there is a RESC_HIER_STR_KW then
// we know that the redirection decision has already been made
std::string hier;
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
irods::error ret = irods::resolve_resource_hierarchy(
irods::CREATE_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
status2 = applyRuleForPostProcForWrite( rsComm, dataObjInpBBuf,
dataObjInp->objPath );
if ( status2 < 0 ) {
return ( status2 );
}
dataObjInp->openFlags = O_RDWR;
status = _rsDataObjPut( rsComm, dataObjInp, dataObjInpBBuf,
portalOprOut );
}
else {
int l1descInx;
status = _rcDataObjPut( rodsServerHost->conn, dataObjInp,
dataObjInpBBuf, portalOprOut );
if ( status < 0 ||
getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL ) {
return status;
}
else {
/* have to allocate a local l1descInx to keep track of things
* since the file is in remote zone. It sets remoteL1descInx,
* oprType = REMOTE_ZONE_OPR and remoteZoneHost so that
* rsComplete knows what to do */
l1descInx = allocAndSetL1descForZoneOpr(
( *portalOprOut )->l1descInx, dataObjInp, rodsServerHost, NULL );
if ( l1descInx < 0 ) {
return l1descInx;
}
( *portalOprOut )->l1descInx = l1descInx;
return status;
}
}
return status;
}
int
rsDataObjRsync( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
msParamArray_t **outParamArray ) {
int status;
char *rsyncMode;
char *remoteZoneOpr;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
*outParamArray = NULL;
if ( dataObjInp == NULL ) {
rodsLog( LOG_ERROR, "rsDataObjRsync error. NULL input" );
return SYS_INTERNAL_NULL_INPUT_ERR;
}
rsyncMode = getValByKey( &dataObjInp->condInput, RSYNC_MODE_KW );
if ( rsyncMode == NULL ) {
rodsLog( LOG_ERROR,
"rsDataObjRsync: RSYNC_MODE_KW input is missing" );
return USER_RSYNC_NO_MODE_INPUT_ERR;
}
if ( strcmp( rsyncMode, LOCAL_TO_IRODS ) == 0 ) {
remoteZoneOpr = REMOTE_CREATE;
}
else {
remoteZoneOpr = REMOTE_OPEN;
}
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
if ( strcmp( rsyncMode, IRODS_TO_IRODS ) == 0 ) {
if ( isLocalZone( dataObjInp->objPath ) == 0 ) {
dataObjInp_t myDataObjInp;
char *destObjPath;
/* source in a remote zone. try dest */
destObjPath = getValByKey( &dataObjInp->condInput,
RSYNC_DEST_PATH_KW );
if ( destObjPath == NULL ) {
rodsLog( LOG_ERROR,
"rsDataObjRsync: RSYNC_DEST_PATH_KW input is missing for %s",
dataObjInp->objPath );
return USER_RSYNC_NO_MODE_INPUT_ERR;
}
myDataObjInp = *dataObjInp;
remoteZoneOpr = REMOTE_CREATE;
rstrcpy( myDataObjInp.objPath, destObjPath, MAX_NAME_LEN );
remoteFlag = getAndConnRemoteZone( rsComm, &myDataObjInp,
&rodsServerHost, remoteZoneOpr );
}
else {
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp,
&rodsServerHost, remoteZoneOpr );
}
}
else {
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
remoteZoneOpr );
}
// =-=-=-=-=-=-=-
// determine the resource hierarchy if one is not provided
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION,
rsComm, dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = _rcDataObjRsync( rodsServerHost->conn, dataObjInp,
outParamArray );
return status;
}
if ( strcmp( rsyncMode, IRODS_TO_LOCAL ) == 0 ) {
status = rsRsyncFileToData( rsComm, dataObjInp );
}
else if ( strcmp( rsyncMode, LOCAL_TO_IRODS ) == 0 ) {
status = rsRsyncDataToFile( rsComm, dataObjInp );
}
else if ( strcmp( rsyncMode, IRODS_TO_IRODS ) == 0 ) {
status = rsRsyncDataToData( rsComm, dataObjInp );
}
else {
rodsLog( LOG_ERROR,
"rsDataObjRsync: rsyncMode %s not supported" );
return USER_RSYNC_NO_MODE_INPUT_ERR;
}
return status;
}
int
rsCollRepl (rsComm_t *rsComm, collInp_t *collReplInp,
collOprStat_t **collOprStat)
{
int status;
dataObjInp_t dataObjInp;
collEnt_t *collEnt;
int handleInx;
transferStat_t myTransStat;
int totalFileCnt;
int fileCntPerStatOut;
int savedStatus = 0;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
/* try to connect to dest resc */
bzero (&dataObjInp, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, collReplInp->collName, MAX_NAME_LEN);
remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost,
REMOTE_CREATE);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
int retval;
retval = _rcCollRepl (rodsServerHost->conn, collReplInp, collOprStat);
if (retval < 0) return retval;
status = svrSendZoneCollOprStat (rsComm, rodsServerHost->conn,
*collOprStat, retval);
return status;
}
fileCntPerStatOut = FILE_CNT_PER_STAT_OUT;
if (collOprStat != NULL) *collOprStat = NULL;
collReplInp->flags = RECUR_QUERY_FG;
handleInx = rsOpenCollection (rsComm, collReplInp);
if (handleInx < 0) {
rodsLog (LOG_ERROR,
"rsCollRepl: rsOpenCollection of %s error. status = %d",
collReplInp->collName, handleInx);
return (handleInx);
}
if (collOprStat != NULL) {
*collOprStat = (collOprStat_t*)malloc (sizeof (collOprStat_t));
memset (*collOprStat, 0, sizeof (collOprStat_t));
}
if (CollHandle[handleInx].rodsObjStat->specColl != NULL) {
rodsLog (LOG_ERROR,
"rsCollRepl: unable to replicate mounted collection %s",
collReplInp->collName);
rsCloseCollection (rsComm, &handleInx);
return (0);
}
while ((status = rsReadCollection (rsComm, &handleInx, &collEnt)) >= 0) {
if (collEnt->objType == DATA_OBJ_T) {
if (totalFileCnt == 0) totalFileCnt =
CollHandle[handleInx].dataObjSqlResult.totalRowCount;
bzero (&dataObjInp, sizeof (dataObjInp));
snprintf (dataObjInp.objPath, MAX_NAME_LEN, "%s/%s",
collEnt->collName, collEnt->dataName);
dataObjInp.condInput = collReplInp->condInput;
memset (&myTransStat, 0, sizeof (myTransStat));
status = _rsDataObjRepl (rsComm, &dataObjInp,
&myTransStat, NULL);
if (status == SYS_COPY_ALREADY_IN_RESC) {
savedStatus = status;
status = 0;
}
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"rsCollRepl: rsDataObjRepl failed for %s. status = %d",
dataObjInp.objPath, status);
savedStatus = status;
break;
} else {
if (collOprStat != NULL) {
(*collOprStat)->bytesWritten += myTransStat.bytesWritten;
(*collOprStat)->filesCnt ++;
}
}
if (collOprStat != NULL &&
(*collOprStat)->filesCnt >= fileCntPerStatOut) {
rstrcpy ((*collOprStat)->lastObjPath, dataObjInp.objPath,
MAX_NAME_LEN);
(*collOprStat)->totalFileCnt = totalFileCnt;
status = svrSendCollOprStat (rsComm, *collOprStat);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"rsCollRepl: svrSendCollOprStat failed for %s. status = %d",
dataObjInp.objPath, status);
*collOprStat = NULL;
savedStatus = status;
break;
}
*collOprStat = (collOprStat_t*)malloc (sizeof (collOprStat_t));
memset (*collOprStat, 0, sizeof (collOprStat_t));
}
}
free (collEnt); /* just free collEnt but not content */
}
rsCloseCollection (rsComm, &handleInx);
return (savedStatus);
}
int
rsStructFileExtAndReg (rsComm_t *rsComm,
structFileExtAndRegInp_t *structFileExtAndRegInp)
{
int status;
dataObjInp_t dataObjInp;
openedDataObjInp_t dataObjCloseInp;
dataObjInfo_t *dataObjInfo;
int l1descInx;
rescInfo_t *rescInfo;
char *rescGroupName;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
char phyBunDir[MAX_NAME_LEN], *tmpStr;
int flags = 0;
#if 0
dataObjInp_t dirRegInp;
structFileOprInp_t structFileOprInp;
#endif
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, structFileExtAndRegInp->objPath, &specCollCache,
&structFileExtAndRegInp->condInput);
resolveLinkedPath (rsComm, structFileExtAndRegInp->collection,
&specCollCache, NULL);
if (!isSameZone (structFileExtAndRegInp->objPath,
structFileExtAndRegInp->collection))
return SYS_CROSS_ZONE_MV_NOT_SUPPORTED;
memset (&dataObjInp, 0, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, structFileExtAndRegInp->objPath,
MAX_NAME_LEN);
/* replicate the condInput. may have resource input */
replKeyVal (&structFileExtAndRegInp->condInput, &dataObjInp.condInput);
dataObjInp.openFlags = O_RDONLY;
remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = rcStructFileExtAndReg (rodsServerHost->conn,
structFileExtAndRegInp);
return status;
}
/* open the structured file */
addKeyVal (&dataObjInp.condInput, NO_OPEN_FLAG_KW, "");
l1descInx = _rsDataObjOpen (rsComm, &dataObjInp);
if (l1descInx < 0) {
rodsLog (LOG_ERROR,
"rsStructFileExtAndReg: _rsDataObjOpen of %s error. status = %d",
dataObjInp.objPath, l1descInx);
return (l1descInx);
}
rescInfo = L1desc[l1descInx].dataObjInfo->rescInfo;
rescGroupName = L1desc[l1descInx].dataObjInfo->rescGroupName;
remoteFlag = resolveHostByRescInfo (rescInfo, &rodsServerHost);
bzero (&dataObjCloseInp, sizeof (dataObjCloseInp));
dataObjCloseInp.l1descInx = l1descInx;
if (remoteFlag == REMOTE_HOST) {
addKeyVal (&structFileExtAndRegInp->condInput, RESC_NAME_KW,
rescInfo->rescName);
if ((status = svrToSvrConnect (rsComm, rodsServerHost)) < 0) {
return status;
}
status = rcStructFileExtAndReg (rodsServerHost->conn,
structFileExtAndRegInp);
rsDataObjClose (rsComm, &dataObjCloseInp);
return status;
}
status = chkCollForExtAndReg (rsComm, structFileExtAndRegInp->collection,
NULL);
if (status < 0) return status;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
createPhyBundleDir (rsComm, dataObjInfo->filePath, phyBunDir);
status = unbunPhyBunFile (rsComm, dataObjInp.objPath, rescInfo,
dataObjInfo->filePath, phyBunDir, dataObjInfo->dataType, 0);
if (status == SYS_DIR_IN_VAULT_NOT_EMPTY) {
/* rename the phyBunDir */
tmpStr = strdup(phyBunDir); // cppcheck - Undefined behavior: same parameter and destination in snprintf().
snprintf (phyBunDir, MAX_NAME_LEN, "%s.%-d", tmpStr, (int) random ());
free(tmpStr);
status = unbunPhyBunFile (rsComm, dataObjInp.objPath, rescInfo,
dataObjInfo->filePath, phyBunDir, dataObjInfo->dataType, 0);
}
if (status < 0) {
rodsLog (LOG_ERROR,
"rsStructFileExtAndReg:unbunPhyBunFile err for %s to dir %s.stat=%d",
dataObjInfo->filePath, phyBunDir, status);
rsDataObjClose (rsComm, &dataObjCloseInp);
return status;
}
if (getValByKey (&structFileExtAndRegInp->condInput, FORCE_FLAG_KW)
!= NULL) {
flags = flags | FORCE_FLAG_FLAG;
}
if (getValByKey (&structFileExtAndRegInp->condInput, BULK_OPR_KW)
!= NULL) {
status = bulkRegUnbunSubfiles (rsComm, rescInfo, rescGroupName,
structFileExtAndRegInp->collection, phyBunDir, flags, NULL);
} else {
status = regUnbunSubfiles (rsComm, rescInfo, rescGroupName,
structFileExtAndRegInp->collection, phyBunDir, flags, NULL);
}
if (status == CAT_NO_ROWS_FOUND) {
/* some subfiles have been deleted. harmless */
status = 0;
} else if (status < 0) {
rodsLog (LOG_ERROR,
"_rsUnbunAndRegPhyBunfile: rsStructFileExtAndReg for dir %s.stat=%d",
phyBunDir, status);
}
rsDataObjClose (rsComm, &dataObjCloseInp);
return status;
}
