int
_rsDataObjCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) {
int status;
rescGrpInfo_t* myRescGrpInfo = 0;
int l1descInx;
/* query rcat for resource info and sort it */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "_rsDataObjCreate : failed in call to getRescGrpForCreate. status = %d", status );
return status;
}
status = l1descInx = _rsDataObjCreateWithRescInfo( rsComm, dataObjInp, myRescGrpInfo->rescInfo, myRescGrpInfo->rescGroupName );
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
// JMC - legacy resource - if (status < 0) {
if ( status >= 0 ) {
return ( status );
}
else {
rodsLog( LOG_NOTICE,
"rsDataObjCreate: Internal error" );
return ( SYS_INTERNAL_NULL_INPUT_ERR );
}
}
/// =-=-=-=-=-=-=-
/// @brief function to handle resolving the hier given the fco and
/// resource keyword
static
error resolve_hier_for_create(
rsComm_t* _comm,
irods::file_object_ptr _file_obj,
const char* _key_word,
dataObjInp_t* _data_obj_inp,
std::string& _out_hier ) {
// =-=-=-=-=-=-=-
// handle the create operation
// check for incoming requested destination resource first
std::string resc_name;
if ( !_key_word ) {
// =-=-=-=-=-=-=-
// this is a 'create' operation and no resource is specified,
// query the server for the default or other resource to use
rescGrpInfo_t* grp_info = 0;
int status = getRescGrpForCreate( _comm, _data_obj_inp, &grp_info );
if ( status < 0 || !grp_info || !grp_info->rescInfo ) {
// =-=-=-=-=-=-=-
// clean up memory
delete grp_info->rescInfo;
delete grp_info;
return ERROR( status, "failed in getRescGrpForCreate" );
}
resc_name = grp_info->rescInfo->rescName;
// =-=-=-=-=-=-=-
// clean up memory
delete grp_info->rescInfo;
delete grp_info;
}
else {
resc_name = _key_word;
}
// =-=-=-=-=-=-=-
// set the resc hier given the root resc name
_file_obj->resc_hier( resc_name );
// =-=-=-=-=-=-=-
// get a vote and hier for the create
float vote = 0.0;
error ret = request_vote_for_file_object(
_comm,
CREATE_OPERATION,
resc_name,
_file_obj,
_out_hier,
vote );
if ( 0.0 == vote ) {
if ( ret.code() == 0 ) {
ret.code( -1 );
}
ret.status( false );
}
return PASS( ret );
} // resolve_hier_for_create
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
l3DataPutSingleBuf( rsComm_t* rsComm,
dataObjInp_t* dataObjInp,
bytesBuf_t* dataObjInpBBuf ) {
int bytesWritten;
int l1descInx;
dataObjInfo_t *myDataObjInfo;
char rescGroupName[NAME_LEN];
rescInfo_t *rescInfo = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
rescGrpInfo_t *tmpRescGrpInfo = NULL;
rescInfo_t *tmpRescInfo = NULL;
int status;
openedDataObjInp_t dataObjCloseInp;
/* don't actually physically open the file */
addKeyVal( &dataObjInp->condInput, NO_OPEN_FLAG_KW, "" );
l1descInx = rsDataObjCreate( rsComm, dataObjInp );
if ( l1descInx <= 2 ) {
if ( l1descInx >= 0 ) {
rodsLog( LOG_ERROR,
"l3DataPutSingleBuf: rsDataObjCreate of %s error, status = %d",
dataObjInp->objPath,
l1descInx );
return SYS_FILE_DESC_OUT_OF_RANGE;
}
else {
return l1descInx;
}
}
bytesWritten = _l3DataPutSingleBuf( rsComm, l1descInx, dataObjInp, dataObjInpBBuf );
if ( bytesWritten < 0 ) {
myDataObjInfo = L1desc[l1descInx].dataObjInfo;
if ( getStructFileType( myDataObjInfo->specColl ) < 0 &&
strlen( myDataObjInfo->rescGroupName ) > 0 &&
( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) == 0 ) {
/* getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) == NULL) { */
/* File not in specColl and resc is a resc group and not
* overwriting existing data. Save resc info in case the put fail
*/
rstrcpy( rescGroupName, myDataObjInfo->rescGroupName, NAME_LEN );
rescInfo = myDataObjInfo->rescInfo;
}
else {
rescGroupName[0] = '\0';
rescInfo = NULL;
}
}
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = bytesWritten;
status = rsDataObjClose( rsComm, &dataObjCloseInp );
if ( status < 0 ) {
rodsLog( LOG_DEBUG,
"l3DataPutSingleBuf: rsDataObjClose of %d error, status = %d",
l1descInx, status );
}
if ( bytesWritten >= 0 ) {
return status;
}
else if ( strlen( rescGroupName ) == 0 ) {
return bytesWritten;
}
/* get here when Put failed. and rescGroupName is a valid resc group.
* Try other resc in the resc group */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
return bytesWritten;
}
tmpRescGrpInfo = myRescGrpInfo;
while ( tmpRescGrpInfo != NULL ) {
tmpRescInfo = tmpRescGrpInfo->rescInfo;
if ( rescInfo == tmpRescInfo ) {
/* already tried this resc */
tmpRescGrpInfo = tmpRescGrpInfo->next;
continue;
}
l1descInx = _rsDataObjCreateWithRescInfo( rsComm,
dataObjInp, tmpRescInfo, myRescGrpInfo->rescGroupName );
if ( l1descInx <= 2 ) {
if ( l1descInx >= 0 ) {
rodsLog( LOG_ERROR,
"l3DataPutSingleBuf:_rsDataObjCreateWithRI %s err,stat = %d",
dataObjInp->objPath, l1descInx );
}
}
else {
bytesWritten = _l3DataPutSingleBuf( rsComm, l1descInx, dataObjInp,
dataObjInpBBuf );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = bytesWritten;
status = rsDataObjClose( rsComm, &dataObjCloseInp );
if ( status < 0 ) {
rodsLog( LOG_DEBUG,
"l3DataPutSingleBuf: rsDataObjClose of %d error, status = %d",
l1descInx, status );
}
if ( bytesWritten >= 0 ) {
bytesWritten = status;
break;
}
}
tmpRescGrpInfo = tmpRescGrpInfo->next;
}
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return bytesWritten;
}
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
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
rsGetHostForPut (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
char **outHost)
{
int status;
rescGrpInfo_t *myRescGrpInfo;
rescInfo_t *myRescInfo;
rodsServerHost_t *rodsServerHost;
rodsHostAddr_t addr;
specCollCache_t *specCollCache = NULL;
char *myHost;
int remoteFlag;
*outHost = NULL;
#if 0
if (isLocalZone (dataObjInp->objPath) == 0) {
/* it is a remote zone. better connect to this host */
*outHost = strdup (THIS_ADDRESS);
return 0;
}
#endif
if (getValByKey (&dataObjInp->condInput, ALL_KW) != NULL ||
getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) {
/* going to ALL copies or overwriting files. not sure which is the
* best */
*outHost = strdup (THIS_ADDRESS);
return 0;
}
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache, NULL);
if (isLocalZone (dataObjInp->objPath) == 0) {
#if 0
/* it is a remote zone. better connect to this host */
*outHost = strdup (THIS_ADDRESS);
return 0;
#else
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
remoteFlag = getAndConnRcatHost (rsComm, SLAVE_RCAT,
dataObjInp->objPath, &rodsServerHost);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == LOCAL_HOST) {
*outHost = strdup (THIS_ADDRESS);
return 0;
} else {
status = rcGetHostForPut (rodsServerHost->conn, dataObjInp,
outHost);
if (status >= 0 && *outHost != NULL &&
strcmp (*outHost, THIS_ADDRESS) == 0) {
free (*outHost);
*outHost = strdup (rodsServerHost->hostName->name);
}
return (status);
}
#endif
}
status = getSpecCollCache (rsComm, dataObjInp->objPath, 0, &specCollCache);
if (status >= 0) {
if (specCollCache->specColl.collClass == MOUNTED_COLL) {
status = resolveResc (specCollCache->specColl.resource,
&myRescInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"rsGetHostForPut: resolveResc error for %s, status = %d",
specCollCache->specColl.resource, status);
return status;
}
/* mounted coll will fall through */
} else {
*outHost = strdup (THIS_ADDRESS);
return 0;
}
} else {
/* normal type */
status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
if (status < 0) return status;
myRescInfo = myRescGrpInfo->rescInfo;
freeAllRescGrpInfo (myRescGrpInfo);
/* status == 1 means random sorting scheme */
if ((status == 1 && getRescCnt (myRescGrpInfo) > 1) ||
getRescClass (myRescInfo) == COMPOUND_CL) {
*outHost = strdup (THIS_ADDRESS);
return 0;
}
}
/* get down here when we got a valid myRescInfo */
bzero (&addr, sizeof (addr));
rstrcpy (addr.hostAddr, myRescInfo->rescLoc, NAME_LEN);
status = resolveHost (&addr, &rodsServerHost);
if (status < 0) return status;
if (rodsServerHost->localFlag == LOCAL_HOST) {
*outHost = strdup (THIS_ADDRESS);
return 0;
}
myHost = getSvrAddr (rodsServerHost);
if (myHost != NULL) {
*outHost = strdup (myHost);
return 0;
} else {
*outHost = NULL;
return SYS_INVALID_SERVER_HOST;
}
}
