int MGroupProcessConfig(
mgcred_t *G, /* I */
char *Value) /* I */
{
char *ptr;
char *TokPtr;
int aindex;
char ValLine[MAX_MNAME];
const char *FName = "MGroupProcessConfig";
DBG(5,fCONFIG) DPrint("%s(%s,%s)\n",
FName,
(G != NULL) ? G->Name : "NULL",
(Value != NULL) ? Value : "NULL");
if ((G == NULL) ||
(Value == NULL) ||
(Value[0] == '\0'))
{
return(FAILURE);
}
/* process value line */
ptr = MUStrTok(Value," \t\n",&TokPtr);
while(ptr != NULL)
{
/* parse name-value pairs */
if (MUGetPair(
ptr,
(const char **)MGroupAttr,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL," \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case mgaClassWeight:
G->ClassWeight = (int)strtol(Value,NULL,0);
break;
default:
/* not handled */
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch(AIndex) */
ptr = MUStrTok(NULL," \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(SUCCESS);
} /* END MGroupProcessConfig() */
int MASLSJobConfig(
mjob_t *J,
char *ConfigString)
{
char *ptr;
char *TokPtr;
int aindex;
char ValLine[MAX_MLINE];
char tmpLine[MAX_MLINE];
int index;
maslsdata_t *D;
if ((J == NULL) || (ConfigString == NULL))
{
return(FAILURE);
}
D = (maslsdata_t *)J->ASData;
if (D == NULL)
return(FAILURE);
/* process config data */
/* FORMAT: INPUT=<INPUTDATANAME>:<INPUTDATASIZE>;OUTPUT=<OUTPUTDATANAME>:<OUTPUTDATASIZE>;STATE=<STATE>; */
ptr = MUStrTok(ConfigString,"; \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr,
(const char **)MASLSAttributeType,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case maslsaState:
index = MUGetIndex(ValLine,MJobState,0,0);
switch(index)
{
case mjsStarting:
case mjsRunning:
if ((D->ASState != mjsStarting) && (D->ASState != mjsRunning))
{
if ((D->IFileSize > 0) && (D->INetRes->Func != NULL))
{
/* initiate stagein transaction */
sprintf(tmpLine,"FILE+=%s:%d",
D->IFileName,
D->IFileSize);
(*D->INetRes->Func)(
&D->INetRes->Data,
mascConfig,
tmpLine,
(void **)&D->IStageTime);
}
D->ASState = index;
}
break;
default:
/* NO-OP */
break;
} /* END switch(index) */
break;
default:
/* NO-OP */
break;
} /* END switch(aindex) */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(SUCCESS);
} /* END MASLSJobConfig() */
int MNodeProcessConfig(
mnode_t *N, /* I (modified) */
mrm_t *R, /* I (optional) */
char *Value) /* I (modified) */
{
char *ptr;
char *TokPtr;
char *ptr2;
char ValBuf[MMAX_BUFFER];
char AttrArray[MMAX_NAME];
int aindex;
enum MNodeAttrEnum AIndex;
int tmpInt;
int tmpI;
double tmpD;
int SlotsUsed = -1;
int rc;
enum MObjectSetModeEnum CIndex;
mbool_t FailureDetected;
const char *FName = "MNodeProcessConfig";
MDB(5,fSTRUCT) MLog("%s(%s,%s,%s)\n",
FName,
(N != NULL) ? N->Name : "NULL",
(R != NULL) ? R->Name : "NULL",
(Value != NULL) ? Value : "NULL");
if ((N == NULL) ||
(Value == NULL) ||
(Value[0] == '\0'))
{
return(FAILURE);
}
ptr = MUStrTokE(Value," \t\n",&TokPtr);
FailureDetected = FALSE;
while (ptr != NULL)
{
/* parse name-value pairs */
/* FORMAT: <ATTR>=<VALUE>[,<VALUE>] */
if (MUGetPair(
ptr,
(const char **)MNodeAttr,
&aindex, /* O */
AttrArray,
TRUE,
&tmpI, /* O */
ValBuf, /* O */
MMAX_BUFFER) == FAILURE)
{
char tmpLine[MMAX_LINE];
/* cannot parse value pair */
snprintf(tmpLine,sizeof(tmpLine),"unknown attribute '%.128s' specified",
ptr);
MDB(3,fSTRUCT) MLog("WARNING: unknown attribute '%s' specified for node %s\n",
ptr,
(N != NULL) ? N->Name : "NULL");
MMBAdd(&N->MB,tmpLine,NULL,mmbtNONE,0,0,NULL);
ptr = MUStrTokE(NULL," \t\n",&TokPtr);
continue;
}
rc = SUCCESS;
AIndex = (enum MNodeAttrEnum)aindex;
switch (tmpI)
{
case 1:
CIndex = mIncr;
break;
case -1:
CIndex = mDecr;
break;
case 0:
default:
CIndex = mSet;
break;
} /* END switch (CIndex) */
switch (AIndex)
{
case mnaAccess:
case mnaAccountList:
case mnaArch:
case mnaCfgClass:
case mnaClassList:
case mnaFlags:
case mnaGroupList:
case mnaJTemplateList:
case mnaNodeIndex:
case mnaPowerPolicy:
case mnaMaxProcPerClass:
case mnaProvRM:
case mnaQOSList:
case mnaUserList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,CIndex);
break;
case mnaComment:
/* add as node message */
{
mmb_t *MB;
MMBAdd(
&N->MB,
(char *)ValBuf,
MSCHED_SNAME,
mmbtAnnotation,
MMAX_TIME,
0,
&MB);
if (MB != NULL)
MUStrDup(&MB->Label,"comment");
} /* END BLOCK (case mnaComment) */
break;
case mnaAvlClass:
if (!bmisset(&N->IFlags,mnifRMClassUpdate))
{
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
}
break;
case mnaAvlMemW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcAMem] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaAvlProcW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcAProcs] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCMem:
{
bmunset(&N->IFlags,mnifMemOverride); /* unset so that new values can be set dynamically */
MNodeSetAttr(N,mnaRCMem,(void **)ValBuf,mdfString,mSet);
if (ValBuf[strlen(ValBuf) - 1] == '^')
bmset(&N->IFlags,mnifMemOverride);
}
break;
case mnaCfgMemW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcCMem] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCProc:
N->CRes.Procs = (int)strtol(ValBuf,NULL,10);
break;
case mnaCfgProcW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcCProcs] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCSwap:
{
bmunset(&N->IFlags,mnifSwapOverride); /* unset so that value can be set dynamically */
MNodeSetAttr(N,mnaRCSwap,(void **)ValBuf,mdfString,mSet);
if (ValBuf[strlen(ValBuf) - 1] == '^')
bmset(&N->IFlags,mnifSwapOverride);
}
break;
case mnaFailure:
{
char *ptr;
char *TokPtr;
int findex;
enum MNodeFailEnum {
mnfNONE,
mnfState,
mnfMem,
mnfSwap,
mnfLoad };
const char *NFType[] = {
NONE,
"STATE",
"MEM",
"SWAP",
"LOAD",
NULL };
ptr = MUStrTok(ValBuf,",",&TokPtr);
while (ptr != NULL)
{
findex = MUGetIndex(ptr,NFType,FALSE,0);
switch (findex)
{
case mnfState:
MNodeSetState(N,mnsDown,FALSE);
if (N->Message == NULL)
{
MUStrDup(&N->Message,"node is down");
}
break;
case mnfMem:
tmpInt = 0;
MNodeSetAttr(N,mnaRAMem,(void **)&tmpInt,mdfInt,mSet);
MUStrDup(&N->Message,"memory is low");
break;
case mnfSwap:
tmpInt = 3;
MNodeSetAttr(N,mnaRASwap,(void **)&tmpInt,mdfInt,mSet);
MUStrDup(&N->Message,"swap is low");
break;
case mnfLoad:
N->ARes.Procs = 0;
N->Load = 4.3;
MUStrDup(&N->Message,"excessive processor usage");
break;
case mnfNONE:
default:
/* NO-OP */
break;
} /* END switch (findex) */
ptr = MUStrTok(NULL,",",&TokPtr);
} /* END while (ptr != NULL) */
} /* END BLOCK */
break;
case mnaFeatures:
{
char tmpBuffer[MMAX_BUFFER];
char *TokPtr2;
/* FORMAT: <FEATURE>[{ ,:}<FEATURE>]... */
/* NOTE: Mode == mDecr NOT supported */
/* if '!' specified, update named feature */
/* NOTE: if features specified via config file, should be appended to features
discovered via RM */
MSched.NodeFeaturesSpecifiedInConfig = TRUE;
if (CIndex == mSet)
{
bmclear(&N->FBM);
}
strcpy(tmpBuffer,ValBuf);
ptr2 = MUStrTok(tmpBuffer,":, \t\n",&TokPtr2);
while (ptr2 != NULL)
{
MNodeProcessFeature(N,ptr2);
ptr2 = MUStrTok(NULL,":, \t\n",&TokPtr2);
} /* END while (ptr != NULL) */
} /* END BLOCK (case mnaFeatures) */
/* Moab owns feature indicated by clearing RM ownership bit */
bmunset(&N->RMAOBM,mnaFeatures);
break;
case mnaCfgGRes:
case mnaChargeRate:
case mnaEnableProfiling:
if (MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet) == FAILURE)
{
/* complete or partial failure setting attribute */
/* NO-OP */
}
break;
case mnaKbdDetectPolicy:
case mnaKbdIdleTime:
case mnaMinPreemptLoad:
case mnaMinResumeKbdIdleTime:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaLoadW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcLoad] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaLogLevel:
N->LogLevel = (int)strtol(ValBuf,NULL,10);
break;
case mnaMaxJob:
{
tmpI = (int)strtol(ValBuf,NULL,10);
if (AttrArray[0] == '\0')
{
N->AP.HLimit[mptMaxJob] = tmpI;
}
else
{
/* NYI */
}
} /* END BLOCK */
break;
case mnaMaxProc:
{
tmpI = (int)strtol(ValBuf,NULL,10);
if (AttrArray[0] == '\0')
{
N->AP.HLimit[mptMaxProc] = tmpI;
}
} /* END BLOCK */
break;
case mnaMaxJobPerGroup:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxJobPerGroup = tmpI;
break;
case mnaMaxJobPerUser:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxJobPerUser = tmpI;
break;
case mnaMaxLoad:
case mnaMaxWCLimitPerJob:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaMaxProcPerGroup:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxProcPerGroup = tmpI;
break;
case mnaMaxProcPerUser:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxProcPerUser = tmpI;
break;
case mnaMaxWatts:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaOS:
case mnaOSList:
case mnaVMOSList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaNodeType:
MUStrDup(&N->NodeType,ValBuf);
break;
case mnaResOvercommitFactor:
case mnaAllocationLimits:
if (N->ResOvercommitFactor == NULL)
{
if ((N->ResOvercommitFactor = (double *)MUCalloc(1,sizeof(double) * mrlLAST)) == NULL)
{
return(FAILURE);
}
}
MUResFactorArrayFromString((char *)ValBuf,N->ResOvercommitFactor,NULL,TRUE,FALSE);
break;
case mnaResOvercommitThreshold:
case mnaUtilizationThresholds:
if (N->ResOvercommitThreshold == NULL)
{
if ((N->ResOvercommitThreshold = (double *)MUCalloc(1,sizeof(double) * mrlLAST)) == NULL)
{
return(FAILURE);
}
}
if (N->GMetricOvercommitThreshold == NULL)
{
int gmindex;
if ((N->GMetricOvercommitThreshold = (double *)MUCalloc(1,sizeof(double) * MSched.M[mxoxGMetric])) == NULL)
{
return(FAILURE);
}
/* initialize all thresholds to 'unset' value */
for (gmindex = 0;gmindex < MSched.M[mxoxGMetric]; gmindex++)
{
N->GMetricOvercommitThreshold[gmindex] = MDEF_GMETRIC_VALUE;
}
}
MUResFactorArrayFromString((char *)ValBuf,N->ResOvercommitThreshold,N->GMetricOvercommitThreshold,TRUE,FALSE);
break;
case mnaOwner:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaPartition:
case mnaPreemptMaxCPULoad:
case mnaPreemptMinMemAvail:
case mnaPreemptPolicy:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaPrioF:
{
mnprio_t *tmpPriorityFunc = NULL;
if (MProcessNAPrioF(&tmpPriorityFunc,ValBuf) == FAILURE)
{
MNPrioFree(&tmpPriorityFunc);
return(FAILURE);
}
/* clear out existing priority function */
MNPrioFree(&N->P);
N->P = tmpPriorityFunc;
} /* END BLOCK */
break;
case mnaPriority:
N->Priority = (int)strtol(ValBuf,NULL,10);
N->PrioritySet = TRUE;
break;
case mnaPrioW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcPriority] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaProcSpeed:
tmpI = (int)strtol(ValBuf,NULL,10);
N->ProcSpeed = tmpI;
break;
case mnaRack:
{
/* FORMAT: <RACKINDEX>|<RACKNAME> */
if (isdigit(ValBuf[0]))
{
tmpI = (int)strtol(ValBuf,NULL,10);
}
else
{
if (MRackAdd(ValBuf,&tmpI,NULL) == FAILURE)
{
/* cannot add rack */
break;
}
}
rc = MNodeSetAttr(N,mnaRack,(void **)&tmpI,mdfInt,mSet);
} /* END BLOCK */
break;
case mnaRADisk:
case mnaRCDisk:
case mnaMaxPE:
case mnaMaxPEPerJob:
case mnaRMList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaSize:
tmpI = (int)strtol(ValBuf,NULL,10);
SlotsUsed = tmpI;
break;
case mnaSlot:
rc = MNodeSetAttr(N,mnaSlot,(void **)ValBuf,mdfString,mSet);
break;
case mnaSpeed:
tmpD = strtod(ValBuf,NULL);
if (tmpD == 0.0)
{
tmpD = 0.01;
}
N->Speed = MIN(100.0,tmpD);
break;
case mnaSpeedW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcSpeed] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaTrigger:
{
marray_t TList;
int tindex;
mtrig_t *T;
MUArrayListCreate(&TList,sizeof(mtrig_t *),4);
MTrigLoadString(&N->T,ValBuf,TRUE,FALSE,mxoNode,N->Name,&TList,NULL);
if (N->T != NULL)
{
for (tindex = 0;tindex < TList.NumItems;tindex++)
{
T = (mtrig_t *)MUArrayListGetPtr(&TList,tindex);
if (MTrigIsValid(T) == FALSE)
continue;
MTrigInitialize(T);
} /* END for (tindex) */
}
MUArrayListFree(&TList);
} /* END BLOCK mnaTrigger */
break;
case mnaUsageW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcUsage] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
#if 0
/* this is not used anywhere */
case mnaResource:
/* FORMAT: <RESNAME>:<RESCOUNT>[,<RESNAME>:<RESCOUNT>]... */
{
char *ptr;
char *TokPtr;
ptr = MUStrTok(ValBuf,", \t",&TokPtr);
while (ptr != NULL)
{
/* FORMAT: <RESDESC>[{ \t,}<RESDESC]... */
MNodeSetAttr(N,mnaCfgGRes,(void **)ptr,mdfString,mSet);
ptr = MUStrTok(NULL,", \t",&TokPtr);
}
} /* END BLOCK */
break;
#endif
case mnaVariables:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
default:
/* NO-OP */
break;
} /* END switch (AIndex) */
if (rc == FAILURE)
FailureDetected = TRUE;
ptr = MUStrTokE(NULL," \t\n",&TokPtr);
} /* END while (ptr != NULL) */
if (FailureDetected == TRUE)
{
return(FAILURE);
}
/* sync 'side-effects' */
if (SlotsUsed > 0)
{
N->SlotsUsed = SlotsUsed;
if ((N->RackIndex > 0) && (N->SlotIndex > 0))
MSys[N->RackIndex][N->SlotIndex].SlotsUsed = SlotsUsed;
}
return(SUCCESS);
} /* END MNodeProcessConfig() */
int MASLSJobCreate(
mjob_t *J,
char *ConfigString)
{
char *ptr;
char *TokPtr;
char *ptr2;
char *TokPtr2;
char *ptr3;
char ValLine[MAX_MLINE];
int aindex;
mreq_t *RQ;
maslsdata_t *D;
if (J == NULL)
return(FAILURE);
/* NOTE: by default, each job uses 100% of all dedicated resources */
/* set 'RQ->URes.Procs' */
/* set 'RQ->URes.Mem' */
/* create AS data structure */
if (J->ASData == NULL)
{
J->ASData = calloc(1,sizeof(maslsdata_t));
}
D = (maslsdata_t *)J->ASData;
if (ConfigString != NULL)
{
/* process config data */
/* FORMAT: INPUT=<INPUTDATANAME>:<INPUTDATASIZE>;OUTPUT=<OUTPUTDATANAME>:<OUTPUTDATASIZE> */
ptr = MUStrTok(ConfigString,"; \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr,
(const char **)MASLSAttributeType,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case maslsaInput:
/* FORMAT: <FILENAME>[<@<SOURCE>]:<FILESIZE> */
if (strchr(ValLine,'@') != NULL)
{
if ((ptr2 = MUStrTok(ValLine,":@",&TokPtr2)) != NULL)
{
MUStrDup(&D->IFileName,ptr2);
if ((ptr2 = MUStrTok(NULL,":@",&TokPtr2)) != NULL)
{
MGResFind(ptr2,-1,&D->INetRes);
}
}
}
else
{
if ((ptr2 = MUStrTok(ValLine,":",&TokPtr2)) != NULL)
{
MUStrDup(&D->IFileName,ptr2);
}
}
if (D->INetRes == NULL)
{
MGResFind(NULL,-1,&D->INetRes);
}
if ((ptr2 = MUStrTok(NULL,":@",&TokPtr2)) != NULL)
{
D->IFileSize = (int)strtol(ptr2,NULL,0);
}
D->IFileStaged = 0;
break;
case maslsaOutput:
/* FORMAT: <FILENAME>[<@<SOURCE>]:<FILESIZE> */
if (strchr(ValLine,'@') != NULL)
{
if ((ptr2 = MUStrTok(ValLine,":@",&TokPtr2)) != NULL)
{
MUStrDup(&D->OFileName,ptr2);
if ((ptr2 = MUStrTok(NULL,":@",&TokPtr2)) != NULL)
{
MGResFind(ptr2,-1,&D->ONetRes);
}
}
}
else
{
if ((ptr2 = MUStrTok(ValLine,":",&TokPtr2)) != NULL)
{
MUStrDup(&D->OFileName,ptr2);
}
}
if (D->ONetRes == NULL)
{
MGResFind(NULL,-1,&D->ONetRes);
}
if ((ptr2 = MUStrTok(NULL,":@",&TokPtr2)) != NULL)
{
D->OFileSize = (int)strtol(ptr2,NULL,0);
}
D->OFileStaged = 0;
break;
default:
break;
} /* END switch(aindex) */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
} /* END while (ptr != NULL) */
} /* END if (ConfigString != NULL) */
/* clear resource usage */
RQ = J->Req[0];
memset(&RQ->URes,0,sizeof(RQ->URes));
return(SUCCESS);
} /* END MASLSJobCreate() */
int MASNet1Create(
masnet1_t **N,
char *ConfigString)
{
char *ptr;
char *TokPtr;
char ValLine[MAX_MLINE];
int aindex;
mreq_t *RQ;
if (N == NULL)
return(FAILURE);
/* create AS data structure */
if (*N == NULL)
{
*N = (masnet1_t *)calloc(1,sizeof(masnet1_t));
}
if (ConfigString != NULL)
{
/* process config data */
/* FORMAT: BANDWIDTH=<BANDWIDTH>;NAME=<NAME>;STATE=<ACTIVE>... */
ptr = MUStrTok(ConfigString,"; \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr,
(const char **)MASNet1AttributeType,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case masnet1aBandwidth:
/* FORMAT: <BANDWIDTH> */
(*N)->Bandwidth = (int)strtol(ValLine,NULL,0);
break;
case masnet1aName:
MUStrDup(&(*N)->Name,ValLine);
break;
case masnet1aState:
/* enable network by default */
(*N)->State = 1;
break;
default:
break;
} /* END switch(aindex) */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
} /* END while (ptr != NULL) */
} /* END if (ConfigString != NULL) */
/* clear network state */
/* NYI */
return(SUCCESS);
} /* END MASNet1Create() */
int MASNet1Config(
masnet1_t *N,
char *ConfigString,
void **OData)
{
int aindex;
char *ptr;
char *TokPtr;
char *TokPtr2;
char *FName;
char *tmpP;
int Size;
char ValLine[MAX_MNAME];
int CmpMode;
int tindex;
masnet1trans_t **T;
if ((N == NULL) || (ConfigString == NULL))
{
return(FAILURE);
}
/* process config data */
/* FORMAT: [BANDWIDTH[+=|-=]<VAL>][;FILE=<NAME>:<SIZE>]... */
ptr = MUStrTok(ConfigString,"; \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr,
(const char **)MASNet1AttributeType,
&aindex,
NULL,
TRUE,
&CmpMode,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case masnet1aFile:
/* FORMAT: <FILENAME>:<FILESIZE> */
FName = MUStrTok(ValLine,":",&TokPtr2);
if ((tmpP = MUStrTok(NULL,":",&TokPtr2)) != NULL)
{
Size = (int)strtol(tmpP,NULL,0);
}
else
{
Size = -1;
}
if (CmpMode == -1)
{
/* locate and remove transaction */
for (tindex = 0;tindex < MAX_MNODE;tindex++)
{
T = &N->ActiveList[tindex];
if (*T == (masnet1trans_t *)NULL)
break;
if (*T == (masnet1trans_t *)1)
continue;
if (!strcmp((*T)->FileName,FName))
{
MASNet1TransDestroy(T);
break;
}
} /* END for (tindex) */
}
else
{
/* create new transaction */
MASNet1TransCreate(
N,
FName,
Size,
(long *)OData);
}
break;
default:
break;
} /* END switch (aindex) */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(FAILURE);
} /* MASNet1Config() */
double MLocalApplyCosts(
mulong Duration, /* I */
int TC, /* I */
char *VarList) /* I */
{
char tmpLine[MMAX_LINE];
char *ptr;
char *TokPtr;
int aindex;
int tmpI;
double Cost;
char ValLine[MMAX_LINE];
const char *VName[] = {
NONE,
"collection",
"querytype",
NULL };
enum {
mlvlNONE = 0,
mlvlCollection,
mlvlQueryType };
if ((Duration == 0) || (TC == 0) || (VarList == NULL) || (VarList[0] == '\0'))
{
return(0.0);
}
Cost = 0.0;
MUStrCpy(tmpLine,VarList,sizeof(tmpLine));
/* FORMAT: <ATTR>=<VAL>[,<ATTR>=<VAL>]... */
ptr = MUStrTok(tmpLine,", \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr, /* I */
(const char **)VName,
&aindex, /* O (attribute) */
NULL,
FALSE,
&tmpI, /* O (relative comparison) */
ValLine, /* O (value) */
sizeof(ValLine)) == FAILURE)
{
/* cannot parse value pair */
MDB(2,fSCHED) MLog("ALERT: cannot parse env variable '%s'\n",
ptr);
ptr = MUStrTok(NULL," \t\n",&TokPtr);
continue;
}
switch (aindex)
{
case mlvlCollection:
if (!strcasecmp(ValLine,"master"))
Cost += 5000;
else if (!strcasecmp(ValLine,"basic"))
Cost += 1000;
break;
case mlvlQueryType:
if (!strcasecmp(ValLine,"full"))
Cost += 2000;
else if (!strcasecmp(ValLine,"basic"))
Cost += 400;
break;
default:
/* ignore variable */
/* NO-OP */
break;
} /* END switch (aindex) */
ptr = MUStrTok(NULL," \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(Cost);
} /* END MLocalApplyCosts() */
int MClassProcessConfig(
mclass_t *C, /* I (modified) */
char *Value) /* I */
{
char *ptr;
char *TokPtr;
int aindex;
char ValLine[MAX_MNAME];
const char *FName = "MClassProcessConfig";
DBG(5,fCONFIG) DPrint("%s(%s,%s)\n",
FName,
(C != NULL) ? C->Name : "NULL",
(Value != NULL) ? Value : "NULL");
if ((C == NULL) ||
(Value == NULL) ||
(Value[0] == '\0'))
{
return(FAILURE);
}
/* process value line */
ptr = MUStrTok(Value," \t\n",&TokPtr);
while(ptr != NULL)
{
/* parse name-value pairs */
if (MUGetPair(
ptr,
(const char **)MClassAttr,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL," \t\n",&TokPtr);
continue;
}
/* NOTE: only allow certain attributes to be set via config */
switch(aindex)
{
case mclaNAPolicy:
C->NAPolicy = MUGetIndex(ValLine,MNAccessPolicy,FALSE,0);
break;
case mclaOCNode:
case mclaDefReqFeature:
case mclaMaxProcPerNode:
case mclaWCOverrun:
MClassSetAttr(C,aindex,(void **)ValLine,mdfString,mSet);
break;
default:
/* NO-OP */
break;
} /* END switch(AIndex) */
ptr = MUStrTok(NULL," \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(SUCCESS);
} /* END MClassProcessConfig() */
