/**
* \cond oldruleengine
* \fn remoteExec(msParam_t *mPD, msParam_t *mPA, msParam_t *mPB, msParam_t *mPC, ruleExecInfo_t *rei)
*
* \brief A set of statements to be remotely executed
*
* \module core
*
* \since pre-2.1
*
* \author Arcot Rajasekar
* \date 2008
*
* \note This micoservice takes a set of microservices that need to be executed at a
* remote iRODS server. The execution is done immediately and synchronously with
* the result returning back from the call.
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] mPD - a msParam of type STR_MS_T which is a host name of the server where the body need to be executed.
* \param[in] mPA - a msParam of type STR_MS_T which is a delayCondition about when to execute the body.
* \param[in] mPB - a msParam of type STR_MS_T which is a body. A statement list - micro-services and ruleNames separated by ##
* \param[in] mPC - a msParam of type STR_MS_T which is arecoverBody. A statement list - micro-services and ruleNames separated by ##
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \pre none
* \post none
* \sa none
* \endcond
**/
int remoteExec( msParam_t *mPD, msParam_t *mPA, msParam_t *mPB, msParam_t *mPC, ruleExecInfo_t *rei ) {
int i;
execMyRuleInp_t execMyRuleInp;
msParamArray_t *tmpParamArray, *aParamArray;
msParamArray_t *outParamArray = NULL;
char tmpStr[LONG_NAME_LEN];
char tmpStr1[LONG_NAME_LEN];
/*
char actionCall[MAX_ACTION_SIZE];
char recoveryActionCall[MAX_ACTION_SIZE];
char delayCondition[MAX_ACTION_SIZE];
char hostName[MAX_ACTION_SIZE];
rstrcpy(hostName, (char *) mPD->inOutStruct,MAX_ACTION_SIZE);
rstrcpy(delayCondition, (char *) mPA->inOutStruct,MAX_ACTION_SIZE);
rstrcpy(actionCall, (char *) mPB->inOutStruct,MAX_ACTION_SIZE);
rstrcpy(recoveryActionCall, (char *) mPC->inOutStruct,MAX_ACTION_SIZE);
i = _remoteExec(actionCall, recoveryActionCall, delayCondition, hostName, rei);
*/
memset( &execMyRuleInp, 0, sizeof( execMyRuleInp ) );
execMyRuleInp.condInput.len = 0;
rstrcpy( execMyRuleInp.outParamDesc, ALL_MS_PARAM_KW, LONG_NAME_LEN );
/* rstrcpy (execMyRuleInp.addr.hostAddr, mPD->inOutStruct, LONG_NAME_LEN);*/
rstrcpy( tmpStr, ( char * ) mPD->inOutStruct, LONG_NAME_LEN );
i = evaluateExpression( tmpStr, tmpStr1, rei );
if ( i < 0 ) {
return( i );
}
parseHostAddrStr( tmpStr1, &execMyRuleInp.addr );
if ( strlen( ( char* )mPC->inOutStruct ) != 0 ) {
snprintf( execMyRuleInp.myRule, META_STR_LEN, "remExec||%s|%s", ( char* )mPB->inOutStruct, ( char* )mPC->inOutStruct );
}
else {
snprintf( execMyRuleInp.myRule, META_STR_LEN, "remExec{%s}", ( char* )mPB->inOutStruct );
}
addKeyVal( &execMyRuleInp.condInput, "execCondition", ( char * ) mPA->inOutStruct );
tmpParamArray = ( msParamArray_t * ) malloc( sizeof( msParamArray_t ) );
memset( tmpParamArray, 0, sizeof( msParamArray_t ) );
i = replMsParamArray( rei->msParamArray, tmpParamArray );
if ( i < 0 ) {
free( tmpParamArray );
return( i );
}
aParamArray = rei->msParamArray;
rei->msParamArray = tmpParamArray;
execMyRuleInp.inpParamArray = rei->msParamArray;
i = rsExecMyRule( rei->rsComm, &execMyRuleInp, &outParamArray );
carryOverMsParam( outParamArray, aParamArray );
rei->msParamArray = aParamArray;
clearMsParamArray( tmpParamArray, 0 );
free( tmpParamArray );
return( i );
}
int
initZone( rsComm_t *rsComm ) {
rodsServerHost_t *tmpRodsServerHost;
rodsServerHost_t *masterServerHost = NULL;
rodsServerHost_t *slaveServerHost = NULL;
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
int status, i;
sqlResult_t *zoneName, *zoneType, *zoneConn, *zoneComment;
char *tmpZoneName, *tmpZoneType, *tmpZoneConn;//, *tmpZoneComment;
irods::server_properties& props = irods::server_properties::getInstance();
irods::error ret = props.capture_if_needed();
if ( !ret.ok() ) {
irods::log( PASS( ret ) );
return ret.code();
}
std::string zone_name;
ret = props.get_property <
std::string > (
irods::CFG_ZONE_NAME,
zone_name );
if ( !ret.ok() ) {
irods::log( PASS( ret ) );
return ret.code();
}
/* configure the local zone first or rsGenQuery would not work */
tmpRodsServerHost = ServerHostHead;
while ( tmpRodsServerHost != NULL ) {
if ( tmpRodsServerHost->rcatEnabled == LOCAL_ICAT ) {
tmpRodsServerHost->zoneInfo = ZoneInfoHead;
masterServerHost = tmpRodsServerHost;
}
else if ( tmpRodsServerHost->rcatEnabled == LOCAL_SLAVE_ICAT ) {
tmpRodsServerHost->zoneInfo = ZoneInfoHead;
slaveServerHost = tmpRodsServerHost;
}
tmpRodsServerHost = tmpRodsServerHost->next;
}
ZoneInfoHead->masterServerHost = masterServerHost;
ZoneInfoHead->slaveServerHost = slaveServerHost;
memset( &genQueryInp, 0, sizeof( genQueryInp ) );
addInxIval( &genQueryInp.selectInp, COL_ZONE_NAME, 1 );
addInxIval( &genQueryInp.selectInp, COL_ZONE_TYPE, 1 );
addInxIval( &genQueryInp.selectInp, COL_ZONE_CONNECTION, 1 );
addInxIval( &genQueryInp.selectInp, COL_ZONE_COMMENT, 1 );
genQueryInp.maxRows = MAX_SQL_ROWS;
status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );
clearGenQueryInp( &genQueryInp );
if ( status < 0 ) {
freeGenQueryOut( &genQueryOut );
rodsLog( LOG_NOTICE,
"initZone: rsGenQuery error, status = %d", status );
return status;
}
if ( genQueryOut == NULL ) {
rodsLog( LOG_NOTICE,
"initZone: NULL genQueryOut" );
return CAT_NO_ROWS_FOUND;
}
if ( ( zoneName = getSqlResultByInx( genQueryOut, COL_ZONE_NAME ) ) == NULL ) {
rodsLog( LOG_NOTICE,
"initZone: getSqlResultByInx for COL_ZONE_NAME failed" );
return UNMATCHED_KEY_OR_INDEX;
}
if ( ( zoneType = getSqlResultByInx( genQueryOut, COL_ZONE_TYPE ) ) == NULL ) {
rodsLog( LOG_NOTICE,
"initZone: getSqlResultByInx for COL_ZONE_TYPE failed" );
return UNMATCHED_KEY_OR_INDEX;
}
if ( ( zoneConn = getSqlResultByInx( genQueryOut, COL_ZONE_CONNECTION ) ) == NULL ) {
rodsLog( LOG_NOTICE,
"initZone: getSqlResultByInx for COL_ZONE_CONNECTION failed" );
return UNMATCHED_KEY_OR_INDEX;
}
if ( ( zoneComment = getSqlResultByInx( genQueryOut, COL_ZONE_COMMENT ) ) == NULL ) {
rodsLog( LOG_NOTICE,
"initZone: getSqlResultByInx for COL_ZONE_COMMENT failed" );
return UNMATCHED_KEY_OR_INDEX;
}
for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
rodsHostAddr_t addr;
tmpZoneName = &zoneName->value[zoneName->len * i];
tmpZoneType = &zoneType->value[zoneType->len * i];
tmpZoneConn = &zoneConn->value[zoneConn->len * i];
//tmpZoneComment = &zoneComment->value[zoneComment->len * i];
if ( strcmp( tmpZoneType, "local" ) == 0 ) {
if ( strcmp( zone_name.c_str(), tmpZoneName ) != 0 ) {
rodsLog( LOG_ERROR,
"initZone: zoneName in env %s does not match %s in icat ",
zone_name.c_str(), tmpZoneName );
}
/* fillin rodsZone if it is not defined */
if ( strlen( rsComm->proxyUser.rodsZone ) == 0 ) {
rstrcpy( rsComm->proxyUser.rodsZone, tmpZoneName, NAME_LEN );
}
if ( strlen( rsComm->clientUser.rodsZone ) == 0 ) {
rstrcpy( rsComm->clientUser.rodsZone, tmpZoneName, NAME_LEN );
}
continue;
}
else if ( strlen( tmpZoneConn ) <= 0 ) {
rodsLog( LOG_ERROR,
"initZone: connection info for zone %s not configured",
tmpZoneName );
continue;
}
memset( &addr, 0, sizeof( addr ) );
/* assume address:port */
parseHostAddrStr( tmpZoneConn, &addr );
if ( addr.portNum == 0 ) {
addr.portNum = ZoneInfoHead->portNum;
}
rstrcpy( addr.zoneName, tmpZoneName, NAME_LEN ); // JMC - bacport 4562
status = resolveHost( &addr, &tmpRodsServerHost );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"initZone: resolveHost error for %s for zone %s. status = %d",
addr.hostAddr, tmpZoneName, status );
continue;
}
if ( tmpRodsServerHost->rcatEnabled == LOCAL_ICAT ) {
rodsLog( LOG_ERROR,
"initZone: address %s for remote zone %s already in use",
tmpZoneConn, tmpZoneName );
continue;
}
tmpRodsServerHost->rcatEnabled = REMOTE_ICAT;
/* REMOTE_ICAT is always on a remote host even if it is one the same
* host, but will be on different port */
tmpRodsServerHost->localFlag = REMOTE_HOST; // JMC - bacport 4562
queZone( tmpZoneName, addr.portNum, tmpRodsServerHost, NULL );
}
freeGenQueryOut( &genQueryOut );
return 0;
}
