/**
* msiGetRescAddr
*
* @param[in] rescName the resource name
* @param[out] outAddress the returned IP address
* @param[in,out] rei the rule execution information
* @return the status code, 0 on success
*/
int
msiGetRescAddr( msParam_t *rescName, msParam_t *outAddress,
ruleExecInfo_t *rei )
{
char *tmpPtr;
int status;
rescGrpInfo_t *rescGrpInfo = NULL;
RE_TEST_MACRO( " Calling msiGetRescAddr" );
tmpPtr = parseMspForStr (rescName);
if (tmpPtr == NULL) {
rodsLog (LOG_ERROR, "msiGetRescAddr: missing name input");
rei->status = USER__NULL_INPUT_ERR;
return USER__NULL_INPUT_ERR;
}
status = _getRescInfo (rei->rsComm, tmpPtr, &rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"msiGetRescAddr: _getRescInfo of %s error. stat = %d",
rescName, status);
return status;
}
fillStrInMsParam (outAddress, rescGrpInfo->rescInfo->rescLoc);
rei->status = 0;
return 0;
}
int
_rsProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut)
{
int status;
rodsServerHost_t *rodsServerHost;
int remoteFlag;
rodsHostAddr_t addr;
procStatInp_t myProcStatInp;
char *tmpStr;
if (getValByKey (&procStatInp->condInput, ALL_KW) != NULL) {
status = _rsProcStatAll (rsComm, procStatInp, procStatOut);
return status;
}
if (getValByKey (&procStatInp->condInput, EXEC_LOCALLY_KW) != NULL) {
status = localProcStat (rsComm, procStatInp, procStatOut);
return status;
}
bzero (&addr, sizeof (addr));
bzero (&myProcStatInp, sizeof (myProcStatInp));
if (*procStatInp->addr != '\0') { /* given input addr */
rstrcpy (addr.hostAddr, procStatInp->addr, LONG_NAME_LEN);
remoteFlag = resolveHost (&addr, &rodsServerHost);
} else if ((tmpStr = getValByKey (&procStatInp->condInput, RESC_NAME_KW))
!= NULL) {
rescGrpInfo_t *rescGrpInfo = NULL;
status = _getRescInfo (rsComm, tmpStr, &rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"_rsProcStat: _getRescInfo of %s error. stat = %d",
tmpStr, status);
return status;
}
rstrcpy (procStatInp->addr, rescGrpInfo->rescInfo->rescLoc, NAME_LEN);
rodsServerHost = (rodsServerHost_t*)rescGrpInfo->rescInfo->rodsServerHost;
if (rodsServerHost == NULL) {
remoteFlag = SYS_INVALID_SERVER_HOST;
} else {
remoteFlag = rodsServerHost->localFlag;
}
} else {
/* do the IES server */
remoteFlag = getRcatHost (MASTER_RCAT, NULL, &rodsServerHost);
}
if (remoteFlag < 0) {
rodsLog (LOG_ERROR,
"_rsProcStat: getRcatHost() failed. erro=%d", remoteFlag);
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
addKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW, "");
status = remoteProcStat (rsComm, &myProcStatInp, procStatOut,
rodsServerHost);
rmKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW);
} else {
status = localProcStat (rsComm, procStatInp, procStatOut);
}
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;
}
