mbool_t MNodeHasClassInExpression(
char *Expression,
mnode_t *N)
{
char *ptr;
char *TokPtr = NULL;
mclass_t *C;
int NC = 0;
MASSERT(Expression != NULL, "NULL Expression pointer testing for Class in Expression");
MASSERT(N != NULL, "NULL Node pointer Class in Expression");
/* Parse off "class:" */
ptr = MUStrTok(Expression,":",&TokPtr);
ptr = MUStrTok(NULL,",:",&TokPtr); /* Point to first class name */
while(ptr != NULL)
{
/* If class can be found. */
if (MClassFind(ptr,&C) != FAILURE)
{
/* If Node has it */
if (bmisset(&N->Classes,C->Index))
{
NC++; /* Count it */
break; /* We only need to find one class */
}
}
ptr = MUStrTok(NULL,",:",&TokPtr); /* Get next class name */
}
return(NC != 0); /* Return TRUE if class found in node */
} /* END MNodeHasClassInExpression() */
int MCfgProcessLine(
int CIndex, /* I */
char *IndexName, /* I (optional) */
char *Line, /* I */
char *Msg) /* O (optional) */
{
int IVal;
double DVal;
char *SVal;
char *SArray[MAX_MINDEX];
char *NullString = "";
char *ptr;
int MIndex;
char *TokPtr;
int PIndex;
mpar_t *P = NULL;
mfsc_t *F = NULL;
mam_t *A = NULL;
mrm_t *R = NULL;
sres_t *SR = NULL;
mqos_t *Q = NULL;
const char *FName = "MCfgProcessLine";
PIndex = MCfg[CIndex].PIndex;
DBG(3,fCONFIG) DPrint("%s(%s,%s,%s)\n",
FName,
MParam[PIndex],
(IndexName != NULL) ? IndexName : "NULL",
Line);
switch(MCfg[CIndex].OType)
{
case mxoSRes:
/* verify SR exists */
/* NOTE: no default SR */
if (MSRAdd(IndexName,&SR) == FAILURE)
{
DBG(2,fCONFIG) DPrint("ALERT: cannot configure SR[%s]\n",
IndexName);
return(FAILURE);
}
break;
case mxoPar:
if (IndexName[0] == '\0')
{
/* default index selects global partition */
P = &MPar[0];
}
else if (MParAdd(IndexName,&P) == FAILURE)
{
DBG(2,fCONFIG) DPrint("ALERT: cannot configure MPar[%s]\n",
IndexName);
return(FAILURE);
}
F = &P->FSC;
break;
case mxoQOS:
/* NOTE: no default QOS */
if (MQOSAdd(IndexName,&Q) == FAILURE)
{
DBG(2,fCONFIG) DPrint("ALERT: cannot configure MQOS[%s]\n",
IndexName);
return(FAILURE);
}
break;
case mxoAM:
if (MAM[0].Name[0] == '\0')
{
/* NOTE: base config only enables primary AM */
MAMAdd("base",&A);
}
break;
case mxoRM:
if (IndexName[0] == '\0')
{
/* default index selects base RM */
R = &MRM[0];
}
else if (MRMAdd(IndexName,&R) == FAILURE)
{
DBG(2,fCONFIG) DPrint("ALERT: cannot configure MRM[%s]\n",
IndexName);
return(FAILURE);
}
else
{
MRMSetDefaults(R);
MOLoadPvtConfig((void **)R,mxoRM,NULL,NULL,NULL);
}
break;
} /* END switch(MCfg[CIndex].OType) */
/* initialize values */
IVal = 0;
DVal = 0.0;
SVal = NULL;
MIndex = 0;
SArray[0] = NULL;
/* read config values */
switch(MCfg[CIndex].Format)
{
case mdfStringArray:
/* process string array */
/* check for first string value */
if ((SArray[MIndex] = MUStrTok(Line," \t\n",&TokPtr)) != NULL)
{
DBG(7,fCONFIG) DPrint("INFO: adding value[%d] '%s' to string array\n",
MIndex,
SArray[MIndex]);
MIndex++;
/* load remaining string values */
while ((SArray[MIndex] = MUStrTok(NULL," \t\n",&TokPtr)) != NULL)
{
DBG(7,fCONFIG) DPrint("INFO: adding value[%d] '%s' to string array\n",
MIndex,
SArray[MIndex]);
MIndex++;
}
}
else
{
/* no values located */
DBG(1,fCONFIG) DPrint("WARNING: parameter '%s[%s]' is not assigned a value. using default value\n",
MParam[PIndex],
IndexName);
}
break;
case mdfIntArray:
/* extract integer array */
/* NYI */
break;
case mdfInt:
DBG(7,fCONFIG) DPrint("INFO: parsing values for integer array parameter '%s'\n",
MParam[PIndex]);
if ((ptr = MUStrTok(Line," \t\n",&TokPtr)) == NULL)
{
DBG(1,fCONFIG) DPrint("WARNING: parameter '%s' is not assigned a value (using default value)\n",
MParam[PIndex]);
IVal = -1;
}
else
{
IVal = (int)strtol(ptr,NULL,0);
if ((IVal == 0) && (ptr[0] != '0'))
{
DBG(1,fCONFIG) DPrint("WARNING: Parameter[%02d] '%s' value (%s) cannot be read as an integer (using default value)\n",
PIndex,
MParam[PIndex],
ptr);
IVal = -1;
}
}
break;
case mdfDouble:
/* extract double array */
if ((ptr = MUStrTok(Line," \t\n",&TokPtr)) == NULL)
{
DBG(1,fCONFIG) DPrint("WARNING: parameter '%s' is not assigned a value (using default value)\n",
MParam[PIndex]);
DVal = -1.0;
}
else
{
DVal = strtod(ptr,NULL);
if ((DVal == 0.0) && (ptr[0] != '0'))
{
DBG(1,fCONFIG) DPrint("WARNING: Parameter[%02d] '%s' value (%s) cannot be read as a double (using default value)\n",
PIndex,
MParam[PIndex],
ptr);
DVal = -1.0;
}
}
break;
case mdfDoubleArray:
/* NYI */
break;
case mdfString:
/* process string value */
DBG(7,fCONFIG) DPrint("INFO: parsing value for single string parameter '%s'\n",
MParam[PIndex]);
if ((SVal = MUStrTok(Line," \t\n",&TokPtr)) == NULL)
{
DBG(1,fCONFIG) DPrint("WARNING: NULL value specified for parameter[%d] '%s'\n",
PIndex,
MParam[PIndex]);
SVal = NullString;
}
break;
default:
DBG(0,fCONFIG) DPrint("ERROR: parameter[%d] '%s' not handled\n",
PIndex,
MParam[PIndex]);
break;
} /* END switch (PIndex) */
if (((MCfg[CIndex].Format == mdfInt) && (IVal == -1)) ||
((MCfg[CIndex].Format == mdfIntArray) && (IVal == -1)) ||
((MCfg[CIndex].Format == mdfDouble) && (DVal == -1.0)) ||
((MCfg[CIndex].Format == mdfDoubleArray) && (DVal == -1.0)) ||
((MCfg[CIndex].Format == mdfString) && (SVal == NULL)) ||
((MCfg[CIndex].Format == mdfStringArray) && (SArray[0] == NULL)) ||
((MCfg[CIndex].Format == mdfStringArray) && (SArray[0] == NULL)))
{
/* invalid parameter specified */
DBG(0,fCONFIG) DPrint("ALERT: parameter '%s' has invalid value\n",
MCfg[CIndex].Name);
return(SUCCESS);
}
/* assign values to parameters */
switch(MCfg[CIndex].OType)
{
case mxoSRes:
MSRProcessOConfig(SR,PIndex,IVal,DVal,SVal,SArray);
break;
case mxoAM:
MAMProcessOConfig(A,PIndex,IVal,DVal,SVal,SArray);
break;
case mxoRM:
MRMProcessOConfig(R,PIndex,IVal,DVal,SVal,SArray);
break;
case mxoQOS:
MQOSProcessOConfig(Q,PIndex,IVal,DVal,SVal,SArray);
break;
case mxoSim:
MSimProcessOConfig(&MSim,PIndex,IVal,DVal,SVal,SArray);
break;
case mxoPar:
case mxoSched:
default:
MCfgSetVal(PIndex,IVal,DVal,SVal,SArray,P,IndexName);
break;
} /* END switch(MCfg[CIndex].Type) */
/* log parameter setting */
switch(MCfg[CIndex].Format)
{
case mdfInt:
DBG(4,fCONFIG) DPrint("INFO: parameter '%s' assigned int value %d\n",
MParam[PIndex],
IVal);
break;
case mdfDouble:
DBG(4,fCONFIG) DPrint("INFO: parameter '%s' assigned int value %lf\n",
MParam[PIndex],
DVal);
break;
case mdfString:
DBG(4,fCONFIG) DPrint("INFO: parameter '%s' assigned string value '%s'\n",
MParam[PIndex],
SVal);
break;
case mdfStringArray:
{
char tmpLine[MAX_MLINE];
int index;
tmpLine[0] = '\0';
for (index = 0;index < MIndex;index++)
{
MUStrCat(tmpLine,SArray[index],sizeof(tmpLine));
MUStrCat(tmpLine," ",sizeof(tmpLine));
}
DBG(4,fCONFIG) DPrint("INFO: parameter '%s' assigned string array '%s'\n",
MParam[PIndex],
tmpLine);
} /* END BLOCK */
break;
default:
/* NO-OP */
break;
} /* END switch(MCfg[CIndex].Format) */
return(SUCCESS);
} /* END MCfgProcessLine() */
int MTraceLoadComputeNode(
char *NodeLine, /* I */
mnode_t *N, /* O */
int Version) /* I */
{
char *tok;
char *TokPtr;
char tmpLine[MAX_MLINE];
char tmpNLine[MAX_MLINE];
char ResourceType[MAX_MNAME];
char EventType[MAX_MNAME];
long ETime;
char Name[MAX_MNAME];
char OpsysString[MAX_MNAME];
char ArchString[MAX_MNAME];
char FeatureString[MAX_MLINE];
char ClassString[MAX_MLINE];
char NetworkString[MAX_MLINE];
char GResString[MAX_MLINE];
char tmpSwapBuf[MAX_MNAME];
char tmpMemBuf[MAX_MNAME];
char tmpDiskBuf[MAX_MNAME];
int SlotsUsed;
char RMName[MAX_MNAME];
int FIndex;
int SIndex;
int cindex;
int rc;
/* set default resource attributes */
memset(N,0,sizeof(mnode_t));
N->Load = 0.0;
N->Speed = 1.0;
N->PtIndex = 0;
switch(Version)
{
case 230:
if (strchr(NodeLine,';') != NULL)
{
sprintf(tmpNLine,"IFS-;%.*s",
MAX_MLINE,
NodeLine);
}
else
{
MUStrCpy(tmpNLine,NodeLine,sizeof(tmpNLine));
}
/* FORMAT: <RESOURCETYPE> <EVENTTYPE> <EVENTTIME> <NAME> <RMINDEX> <SWAP> <MEMORY> <DISK> <MAXPROCS> <SLOTSUSED> <FRAMEINDEX> <SLOTINDEX> <OPSYS> <ARCH> [<FEATURE>]* [<CLASS>]* [<NETWORK>]* [<GRES>]* <RES1> <RES2> <RES3> */
rc = MUSScanF(tmpNLine,"%x%s %x%s %ld %x%s %x%s %x%s %x%s %x%s %d %d %d %d %x%s %x%s %x%s %x%s %x%s %x%s %x%s %x%s %x%s %x%s",
MAX_MNAME,
ResourceType,
MAX_MNAME,
EventType,
&ETime,
MAX_MNAME,
Name,
MAX_MNAME,
RMName,
MAX_MNAME,
tmpSwapBuf,
MAX_MNAME,
tmpMemBuf,
MAX_MNAME,
tmpDiskBuf,
&N->CRes.Procs,
&FIndex,
&SIndex,
&SlotsUsed,
MAX_MNAME,
OpsysString,
MAX_MNAME,
ArchString,
MAX_MLINE,
FeatureString,
MAX_MLINE,
ClassString,
MAX_MLINE,
NetworkString,
MAX_MLINE,
GResString,
MAX_MLINE,
tmpLine, /* RES1 */
MAX_MLINE,
tmpLine, /* RES2 */
MAX_MLINE,
tmpLine, /* RES3 */
MAX_MLINE,
tmpLine /* check for too many lines */
);
if ((rc == EOF) || (rc != 21))
{
DBG(3,fSIM) DPrint("ALERT: resource tracefile corruption (%d of %d fields detected) on line '%s'\n",
rc,
21,
NodeLine);
return(FAILURE);
}
/* process node attributes */
N->CRes.Swap = MURSpecToL(tmpSwapBuf,mvmMega,mvmMega);
N->CRes.Mem = MURSpecToL(tmpMemBuf,mvmMega,mvmMega);
N->CRes.Disk = MURSpecToL(tmpDiskBuf,mvmMega,mvmMega);
if (!strcmp(RMName,NONE))
MRMAdd(RMName,&N->RM);
else
MRMAdd(DEFAULT,&N->RM);
/* load Opsys */
if (strstr(OpsysString,MAList[eOpsys][0]) == NULL)
N->ActiveOS = MUMAGetIndex(eOpsys,OpsysString,mAdd);
/* load Arch */
if (strstr(ArchString,MAList[eArch][0]) == NULL)
N->Arch = MUMAGetIndex(eArch,ArchString,mAdd);
memcpy(&N->ARes,&N->CRes,sizeof(N->ARes));
strcpy(N->Name,MNodeAdjustName(Name,0));
/* load classes */
if (MSim.Flags & ((1 << msimfIgnClass) | (1 << msimfIgnAll)))
{
mclass_t *C;
/* ignore specified classes */
MClassAdd("DEFAULT",&C);
N->CRes.PSlot[0].count = N->CRes.Procs;
N->CRes.PSlot[C->Index].count = N->CRes.Procs;
}
else
{
MUNumListFromString(N->CRes.PSlot,ClassString,eClass);
for (cindex = 1;cindex < MAX_MCLASS;cindex++)
{
if (N->CRes.PSlot[cindex].count > 0)
MClassAdd(MAList[eClass][cindex],NULL);
}
}
memcpy(N->ARes.PSlot,N->CRes.PSlot,sizeof(N->ARes.PSlot));
break;
default:
DBG(4,fSIM) DPrint("ALERT: cannot load version %d resource trace record\n",
Version);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch(Version) */
if ((MSim.Flags & ((1 << msimfIgnFrame) | (1 << msimfIgnAll))) ||
(FIndex < 0))
{
N->FrameIndex = -1;
N->SlotIndex = -1;
}
else
{
MFrameAddNode(&MFrame[FIndex],N,SIndex);
if ((N->FrameIndex > 0) && (N->FrameIndex < MAX_MFRAME) &&
(N->SlotIndex > 0) && (N->SlotIndex <= MAX_MSLOTPERFRAME))
{
mhost_t *S;
int nindex;
S = &MSys[N->FrameIndex][N->SlotIndex];
S->SlotsUsed = SlotsUsed;
for (nindex = 0;nindex < MAX_MNETTYPE;nindex++)
strcpy(S->NetName[nindex],N->Name);
if (!strstr(ClassString,"NONE"))
S->Attributes |= (1 << attrBatch);
S->MTime = MSched.Time;
} /* END if ((N->FrameIndex > 0) ... ) */
} /* END else if (MSim.Flags & ((1 << msimfIgnFrame) | ...)) */
/* initialize statistics */
N->STTime = 0;
N->SUTime = 0;
N->SATime = 0;
/* load state */
if (N->CRes.Procs <= 0)
{
N->State = mnsNone;
}
else
{
if (!strcmp(EventType,"AVAILABLE"))
N->State = mnsIdle;
else if (!strcmp(EventType,"DEFINED"))
N->State = mnsDown;
else if (!strcmp(EventType,"DRAINED"))
N->State = mnsDrained;
else
N->State = mnsNONE;
} /* END else (N->CRes.Procs <= 0) */
N->EState = N->State;
memcpy(&N->ARes,&N->CRes,sizeof(N->ARes));
/* load features */
if (strstr(FeatureString,MAList[eFeature][0]) == NULL)
{
tok = MUStrTok(FeatureString,"[]",&TokPtr);
do
{
MNodeProcessFeature(N,tok);
DBG(6,fSIM) DPrint("INFO: feature '%s' added (%s)\n",
tok,
MUMAList(eFeature,N->FBM,sizeof(N->FBM)));
}
while ((tok = MUStrTok(NULL,"[]",&TokPtr)) != NULL);
}
/* load network adapters */
if (strstr(NetworkString,MAList[eNetwork][0]) == NULL)
{
tok = MUStrTok(NetworkString,"[]",&TokPtr);
do
{
N->Network |= MUMAGetBM(eNetwork,tok,mAdd);
DBG(6,fSIM) DPrint("INFO: network '%s' added (%s)\n",
tok,
MUListAttrs(eNetwork,N->Network));
}
while ((tok = MUStrTok(NULL,"[]",&TokPtr)) != NULL);
}
/* load generic resources */
if (!strcmp(GResString,NONE) != 0)
{
MUNumListFromString(N->CRes.GRes,GResString,eGRes);
}
DBG(4,fSIM) DPrint("INFO: node '%s' F:%d/S:%d %06d %04d %06d %02d %02d %10s %10s %20s %20s\n",
N->Name,
N->FrameIndex,
N->SlotIndex,
N->CRes.Swap,
N->CRes.Mem,
N->CRes.Disk,
N->CRes.Procs,
SlotsUsed,
OpsysString,
ArchString,
FeatureString,
MUCAListToString(N->CRes.PSlot,NULL,NULL));
return(SUCCESS);
} /* END MTraceLoadComputeNode() */
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 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 MUIRsvCtl(
msocket_t *S, /* I */
mbitmap_t *AFlags, /* I credential flags (bitmap of enum MRoleEnum) */
char *Auth) /* I */
{
char Command[MMAX_NAME];
char RsvExp[MMAX_LINE];
char FlagString[MMAX_LINE];
char ArgString[MMAX_LINE];
marray_t RsvList;
char tmpLine[MMAX_LINE << 3];
char tmpName[MMAX_LINE];
char tmpVal[MMAX_LINE];
enum MRsvCtlCmdEnum CIndex;
enum MRsvAttrEnum AIndex;
int rc;
mrsv_t *R;
mrm_t *RM;
mgcred_t *U = NULL;
mbool_t IsAdmin;
mxml_t *RE = NULL;
mxml_t *WE = NULL;
mxml_t *DE = NULL;
int rindex;
mbitmap_t Flags;
mbool_t UseUIndex = FALSE;
mbool_t UseGName = FALSE;
mbool_t AppendRsvExp = FALSE;
mgcred_t *RU = NULL;
mgcred_t *RG = NULL;
mgcred_t *RA = NULL;
mqos_t *RQ = NULL;
enum MFormatModeEnum DFormat = mfmNONE;
const char *FName = "MUIRsvCtl";
MDB(2,fUI) MLog("%s(S,%s)\n",
FName,
(Auth != NULL) ? Auth : "NULL");
if (S == NULL)
{
return(FAILURE);
}
/* NOTE: support create, destroy, list, modify */
/* initialize values */
S->WireProtocol = mwpS32;
RsvExp[0] = '\0';
/* process request */
switch (S->WireProtocol)
{
case mwpXML:
case mwpS32:
{
int WTok;
/* FORMAT: <Request action="X" object="Y"><Where/></Request> */
char *ptr;
if (S->RDE != NULL)
{
RE = S->RDE;
}
else if ((S->RPtr != NULL) &&
((ptr = strchr(S->RPtr,'<')) != NULL) &&
(MXMLFromString(&RE,ptr,NULL,NULL) == FAILURE))
{
MDB(3,fUI) MLog("WARNING: corrupt command '%100.100s' received\n",
S->RBuffer);
MUISAddData(S,"ERROR: corrupt command received\n");
return(FAILURE);
}
S->RDE = RE;
if (MXMLGetAttr(RE,MSAN[msanAction],NULL,Command,sizeof(Command)) == FAILURE)
{
MDB(3,fUI) MLog("WARNING: cannot locate command '%100.100s'\n",
S->RBuffer);
MUISAddData(S,"ERROR: cannot locate command\n");
return(FAILURE);
}
WTok = -1;
while (MS3GetWhere(
RE,
&WE,
&WTok,
tmpName, /* O */
sizeof(tmpName),
tmpVal, /* O */
sizeof(tmpVal)) == SUCCESS)
{
/* process 'where' constraints */
AIndex = (enum MRsvAttrEnum)MUGetIndexCI(tmpName,MRsvAttr,FALSE,mraNONE);
if ((AIndex == mraName) || (AIndex == mraUIndex) || (AIndex == mraRsvGroup))
{
if (AppendRsvExp == TRUE)
{
MUStrCat(RsvExp,",",sizeof(RsvExp));
MUStrCat(RsvExp,tmpVal,sizeof(RsvExp));
}
else
{
MUStrCpy(RsvExp,tmpVal,sizeof(RsvExp));
AppendRsvExp = TRUE;
}
if (AIndex == mraUIndex)
UseUIndex = TRUE;
else if (AIndex == mraRsvGroup)
UseGName = TRUE;
}
else
{
switch (AIndex)
{
case mraAAccount:
if (MAcctFind(tmpVal,&RA) == FAILURE)
{
MUISAddData(S,"ERROR: cannot locate requested account\n");
return(FAILURE);
}
break;
case mraAGroup:
if (MGroupFind(tmpVal,&RG) == FAILURE)
{
MUISAddData(S,"ERROR: cannot locate requested group\n");
return(FAILURE);
}
break;
case mraAQOS:
if (MQOSFind(tmpVal,&RQ) == FAILURE)
{
MUISAddData(S,"ERROR: cannot locate requested qos\n");
return(FAILURE);
}
break;
case mraAUser:
if (MUserFind(tmpVal,&RU) == FAILURE)
{
MUISAddData(S,"ERROR: cannot locate requested user\n");
return(FAILURE);
}
break;
default:
MUISAddData(S,"ERROR: incorrect reservation attribute\n");
return(FAILURE);
/* NOTREACHED */
break;
} /* END switch (AIndex) */
} /* END else */
} /* END while (MXMLGetChild() == SUCCESS) */
if (MXMLGetAttr(RE,MSAN[msanFlags],NULL,FlagString,sizeof(FlagString)) == SUCCESS)
{
bmfromstring(FlagString,MClientMode,&Flags);
if (bmisset(&Flags,mcmXML))
{
DFormat = mfmXML;
}
else
{
DFormat = mfmNONE;
}
}
MXMLGetAttr(RE,MSAN[msanArgs],NULL,ArgString,sizeof(ArgString));
} /* END BLOCK (case mwpXML/mwpS3) */
break;
default:
/* not supported */
MUISAddData(S,"ERROR: corrupt command received\n");
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (S->WireProtocol) */
/* process data */
if ((CIndex = (enum MRsvCtlCmdEnum)MUGetIndexCI(
Command,
MRsvCtlCmds,
FALSE,
mrcmNONE)) == mrcmNONE)
{
MDB(3,fUI) MLog("WARNING: unexpected subcommand '%s' received\n",
Command);
sprintf(tmpLine,"ERROR: unexpected subcommand '%s'\n",
Command);
MUISAddData(S,tmpLine);
return(FAILURE);
}
MUserAdd(Auth,&U);
S->SBuffer[0] = '\0';
switch (CIndex)
{
case mrcmCreate:
{
marray_t RList;
char Buffer[MMAX_BUFFER];
int rc;
Buffer[0] = 0;
/* check for unauthorized peers exporting rsv */
if ((Auth != NULL) &&
(!strncasecmp(Auth,"peer:",strlen("peer:"))))
{
if (MRMFind(&Auth[strlen("peer:")],&RM) == FAILURE)
{
/* NYI */
}
else if (!bmisset(&RM->Flags,mrmfRsvImport))
{
MUISAddData(S,"rsv import not enabled for peer");
return(FAILURE);
}
}
MUArrayListCreate(&RList,sizeof(mrsv_t *),50);
rc = MUIRsvCreate(
RE,
Auth,
Buffer, /* O */
sizeof(Buffer),
TRUE,
FALSE,
FALSE,
&RList);
if (DFormat == mfmXML)
{
if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
{
rc = FAILURE;
MUISAddData(S,"ERROR: internal error, cannot create response\n");
}
else if (rc == SUCCESS)
{
mrsv_t *R;
int rindex;
mxml_t *RE;
DE = S->SDE;
for (rindex = 0;rindex < RList.NumItems;rindex++)
{
R = (mrsv_t *)MUArrayListGetPtr(&RList,rindex);
RE = NULL;
MXMLCreateE(&RE,(char *)MXO[mxoRsv]);
MXMLSetVal(RE,R->Name,mdfString);
MXMLAddE(DE,RE);
}
}
else
{
MUISAddData(S,Buffer);
}
} /* END if (DFormat == mfmXML) */
else
{
MUISAddData(S,Buffer);
}
MUArrayListFree(&RList);
return(rc);
} /* END case mrcmCreate: */
case mrcmFlush:
{
msrsv_t *SR;
if (MSRFind(RsvExp,&SR,NULL) == SUCCESS)
{
int sindex;
for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
{
SR->DisabledTimes[sindex] = 0;
}
snprintf(tmpLine,sizeof(tmpLine),"SR[%s] successfully cleared disabled times\n",
SR->Name);
MUISAddData(S,tmpLine);
return(SUCCESS);
}
}
case mrcmQuery:
bmset(&S->Flags,msftReadOnlyCommand);
if (!strcasecmp(ArgString,"profile"))
{
mxml_t *DE;
if ((S->SDE == NULL) &&
(MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE))
{
MUISAddData(S,"ERROR: cannot create response\n");
return(FAILURE);
}
DE = S->SDE;
return(__MUIRsvProfShow(S,U,RsvExp,&DE,NULL));
}
case mrcmList:
bmset(&S->Flags,msftReadOnlyCommand);
break;
default:
break;
} /* end switch(CIndex) */
MUArrayListCreate(&RsvList,sizeof(mrsv_t *),1);
if (UseUIndex == TRUE)
{
char *ptr;
char *TokPtr;
/* locate by unique index */
/* FORMAT: <ID>[,<ID>]... */
/* NOTE: rsv id in format '<NAME>.<UID>' */
ptr = MUStrTok(RsvExp,", \t\n:",&TokPtr);
while (ptr != NULL)
{
if (MRsvFind(ptr,&R,mraUIndex) == SUCCESS)
{
MUArrayListAppendPtr(&RsvList,R);
MDB(6,fUI) MLog("INFO: reservation '%s' located by index\n",
R->Name);
}
else
{
snprintf(tmpLine,sizeof(tmpLine),"ERROR: cannot locate reservation %s\n",
ptr);
MUISAddData(S,tmpLine);
}
ptr = MUStrTok(NULL,", \t\n:",&TokPtr);
} /* END while (ptr != NULL) */
} /* END if (UseUIndex == TRUE) */
else if (UseGName == TRUE)
{
rsv_iter RTI;
char *ptr;
char *TokPtr;
/* allow multiple group selection */
/* FORMAT: <GID>[,<GID>]... */
ptr = MUStrTok(RsvExp,", \t:",&TokPtr);
while (ptr != NULL)
{
MRsvIterInit(&RTI);
while (MRsvTableIterate(&RTI,&R) == SUCCESS)
{
if (R->RsvGroup == NULL)
continue;
if (strcmp(R->RsvGroup,ptr))
continue;
MUArrayListAppendPtr(&RsvList,R);
MDB(6,fUI) MLog("INFO: reservation '%s' located by group '%s'\n",
R->Name,
ptr);
} /* END while (MRsvTableIterate()) */
ptr = MUStrTok(NULL,", \t:",&TokPtr);
} /* END while (ptr != NULL) */
} /* END if (UseGName == TRUE) */
else
{
if (RsvExp[0] == '\0')
{
/* no reservation name received */
snprintf(tmpLine,sizeof(tmpLine),"ERROR: no reservation specified\n");
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
else if ((MUStringIsRE(RsvExp) == TRUE) || (!strcmp(RsvExp,"ALL")))
{
/* regular expression or special expression received */
char tmpBuf[MMAX_BUFFER];
tmpBuf[0] = '\0';
if (MUREToList(
RsvExp,
mxoRsv,
NULL,
&RsvList,
FALSE,
tmpBuf,
sizeof(tmpBuf)) == FAILURE)
{
snprintf(tmpLine,sizeof(tmpLine),"ERROR: invalid expression '%s' : %s\n",
RsvExp,
tmpBuf);
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
}
else
{
/* single reservation specified */
mrsv_t *tmpR = NULL;
if (MRsvFind(RsvExp,&tmpR,mraNONE) == FAILURE)
{
snprintf(tmpLine,sizeof(tmpLine),"ERROR: invalid reservation specified '%s'\n",
RsvExp);
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
else
{
MUArrayListAppendPtr(&RsvList,tmpR);
}
} /* END else */
if (RsvList.NumItems == 0)
{
if (!strcmp(RsvExp,"ALL"))
{
MUArrayListFree(&RsvList);
return(SUCCESS);
}
else
{
char tmpLine[MMAX_LINE];
snprintf(tmpLine,sizeof(tmpLine),"ERROR: '%s' does not match any reservations\n",
RsvExp);
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
} /* END if (RsvList.NumItems == 0) */
} /* END else (UseUIndex == TRUE) */
MDB(2,fUI) MLog("INFO: performing '%s' operation on rsv expression '%s' (%d matches)\n",
MRsvCtlCmds[CIndex],
RsvExp,
RsvList.NumItems);
if (RsvList.NumItems <= 0)
{
/* no reservations found */
sprintf(tmpLine,"ERROR: could not locate any matching reservations\n");
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
rc = SUCCESS;
for (rindex = 0;rindex < RsvList.NumItems;rindex++)
{
R = (mrsv_t *)MUArrayListGetPtr(&RsvList,rindex);
/*
if (((RA != NULL) && (J->Cred.A != RA)) ||
((RG != NULL) && (J->Cred.G != RG)) ||
((RQ != NULL) && (J->Cred.Q != RQ)) ||
((RU != NULL) && (J->Cred.U != RU)))
{
continue;
}
*/
/* get authorization */
if (MUICheckAuthorization(
U,
NULL,
(void *)R,
mxoRsv,
mcsMRsvCtl,
CIndex,
&IsAdmin,
tmpLine,
sizeof(tmpLine)) == FAILURE)
{
/* NOTE: if rsv list is requested, do not report - 'not authorized' message
for each rsv. */
if ((CIndex != mrcmList) && (CIndex != mrcmQuery))
{
MUISAddData(S,tmpLine);
MUISAddData(S,"\n");
/* allow errno to be set on the command line to indicate error */
rc = FAILURE;
}
/* If the final request failed, return failure otherwise continue
to the next request */
if (RsvList.NumItems - 1 == rindex)
{
MUArrayListFree(&RsvList);
/* last request failed */
if (CIndex == mrcmQuery)
{
/* Failed just means no reservations reported */
return(SUCCESS);
}
return(FAILURE);
}
else
{
/* failure is recorded but entire request hasn't failed */
continue;
}
}
switch (CIndex)
{
case mrcmAlloc:
{
char EMsg[MMAX_LINE] = {0};
char tmpName[MMAX_NAME];
char tmpVal[MMAX_NAME];
char GResType[MMAX_NAME];
int len;
GResType[0] = '\0';
/* allocate additional requested resources to specified rsv */
/* FORMAT: mrsvctl -A gres.type=dvd vpc.3 */
/* parse request */
if (MS3GetSet(
RE,
NULL,
NULL,
tmpName,
sizeof(tmpName),
tmpVal,
sizeof(tmpVal)) == FAILURE)
{
sprintf(tmpLine,"ERROR: no allocation resource specified\n");
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
if (!strcasecmp(tmpName,"resource"))
{
len = strlen("gres.type=");
if (!strncasecmp(tmpVal,"gres.type=",len))
{
MUStrCpy(GResType,&tmpVal[len],sizeof(GResType));
}
}
if (GResType[0] == '\0')
{
sprintf(tmpLine,"ERROR: no allocation resource specified\n");
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(FAILURE);
}
/* create pseudo job */
rc = MRsvAllocateGResType(R,GResType,EMsg);
MUISAddData(S,EMsg);
MUArrayListFree(&RsvList);
return(rc);
} /* END case mrcmAlloc */
/*NOTREACHED*/
break;
case mrcmCreate:
{
/* should not be reached (handled above) */
rc = FAILURE;
sprintf(tmpLine,"ERROR: create failed - internal error\n");
MUISAddData(S,tmpLine);
MUArrayListFree(&RsvList);
return(rc);
} /* END case mrcmCreate */
/*NOTREACHED*/
break;
case mrcmDestroy:
{
char tmpName[MMAX_NAME];
if (bmisset(&R->Flags,mrfStatic))
{
sprintf(tmpLine,"ERROR: cannot release 'static' reservation %s\n",
R->Name);
MUISAddData(S,tmpLine);
continue;
}
if (bmisset(&R->Flags,mrfParentLock))
{
sprintf(tmpLine,"ERROR: cannot release 'locked' reservation %s - must remove parent object\n",
R->Name);
MUISAddData(S,tmpLine);
continue;
}
MUStrCpy(tmpName,R->Name,sizeof(tmpName));
R->CancelIsPending = TRUE;
if (bmisset(&R->Flags,mrfStanding))
{
int sindex;
msrsv_t *SR = NULL;
/* set enabletime to the end of this reservation */
if (MSRFind(R->RsvParent,&SR,NULL) == SUCCESS)
{
for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
{
if ((SR->DisabledTimes[sindex] == 0) ||
(SR->DisabledTimes[sindex] == 1))
{
if (R->EndTime == MMAX_TIME - 1)
SR->DisabledTimes[sindex] = MMAX_TIME;
else
SR->DisabledTimes[sindex] = R->EndTime;
break;
}
} /* END for (sindex) */
} /* END if (MSRFind(R->RsvGroup,&SR) == SUCCESS) */
else
{
sprintf(tmpLine,"WARNING: cannot locate rsv parent\n");
MUISAddData(S,tmpLine);
MDB(3,fUI) MLog("WARNING: cannot locate parent '%s' for rsv '%s'\n",
(R->RsvGroup != NULL) ? R->RsvGroup : "NULL",
R->Name);
}
} /* END if (bmisset(&R->Flags,mrfStanding)) */
R->EndTime = MSched.Time - 1;
R->ExpireTime = 0;
snprintf(tmpLine,sizeof(tmpLine),"reservation %s destroyed by %s",
tmpName,
Auth);
MOWriteEvent(R,mxoRsv,mrelRsvCancel,tmpLine,MStat.eventfp,NULL);
if ((long)R->StartTime <= MUIDeadLine)
{
/* adjust UI phase wake up time */
if (MSched.AdminEventAggregationTime >= 0)
MUIDeadLine = MIN(MUIDeadLine,(long)MSched.Time + MSched.AdminEventAggregationTime);
}
/* remove reservation */
if ((R->Type = mrtJob) && (R->J != NULL))
{
/* Expiring job reservations are not released in MRsvCheckStatus(), they are extended.
So to remove the reservation you must do it outside MRsvCheckStatus() */
MJobReleaseRsv(R->J,TRUE,TRUE);
R = NULL;
}
else
{
MRsvCheckStatus(NULL);
}
MOSSyslog(LOG_INFO,tmpLine);
sprintf(tmpLine,"reservation %s successfully released\n",
tmpName);
} /* END case mrcmDestroy */
MUISAddData(S,tmpLine);
continue;
/*NOTREACHED*/
break;
case mrcmFlush:
{
msrsv_t *SR;
int sindex;
if (MSRFind(R->RsvGroup,&SR,NULL) == FAILURE)
{
sprintf(tmpLine,"reservation '%s' does not belong to a standing reservation\n",
R->Name);
MUISAddData(S,tmpLine);
rc = FAILURE;
break;
}
for (sindex = 0;sindex < MMAX_SRSV_DEPTH;sindex++)
{
SR->DisabledTimes[0] = 0;
}
sprintf(tmpLine,"SR[%s] successfully cleared disabled times\n",
SR->Name);
MUISAddData(S,tmpLine);
}
break;
case mrcmJoin:
{
char EMsg[MMAX_LINE] = {0};
mrsv_t *CR = NULL;
if (MRsvFind(ArgString,&CR,mraNONE) == SUCCESS)
{
rc = MRsvJoin(R,CR,EMsg);
if (rc == FAILURE)
{
sprintf(tmpLine,"could not join rsv '%s' to rsv '%s' -- %s\n",
R->Name,
ArgString,
EMsg);
MUISAddData(S,tmpLine);
}
else
{
sprintf(tmpLine,"successfully joined rsv '%s' to rsv '%s'\n",
ArgString,
R->Name);
MHistoryAddEvent(R,mxoRsv);
MUISAddData(S,tmpLine);
}
}
else
{
sprintf(tmpLine,"invalid reservation '%s'\n",
ArgString);
MUISAddData(S,tmpLine);
}
} /* END case mrcmJoin */
break;
case mrcmSignal:
{
enum MTrigTypeEnum Signal = (enum MTrigTypeEnum)MUGetIndexCI(ArgString,MTrigType,FALSE,mttNONE);
if (Signal == mttNONE)
{
sprintf(tmpLine,"invalid signal '%s' for rsv '%s'\n",
ArgString,
R->Name);
MUISAddData(S,tmpLine);
}
else
{
MOReportEvent((void *)R,NULL,mxoRsv,Signal,MSched.Time,TRUE);
sprintf(tmpLine,"signal '%s' successfully sent to rsv '%s'\n",
MTrigType[Signal],
R->Name);
MUISAddData(S,tmpLine);
}
} /* END BLOCK (case mrcmSignal) */
break;
case mrcmList:
/* NOTE: only add matching reservations */
/* NOTE: global list handled outside of loop */
MUISAddData(S,R->Name);
MUISAddData(S," ");
break;
case mrcmMigrate:
{
char EMsg[MMAX_LINE] = {0};
mrsv_t *CR = NULL;
if (MRsvFind(ArgString,&CR,mraNONE) == SUCCESS)
{
rc = MRsvMigrate(R,CR,EMsg);
if (rc == FAILURE)
{
sprintf(tmpLine,"could not migrate rsv '%s' to rsv '%s' -- %s\n",
R->Name,
ArgString,
EMsg);
MUISAddData(S,tmpLine);
}
else
{
sprintf(tmpLine,"successfully migrated rsv '%s' to rsv '%s'\n",
ArgString,
R->Name);
MHistoryAddEvent(R,mxoRsv);
MUISAddData(S,tmpLine);
}
}
else
{
sprintf(tmpLine,"invalid reservation '%s'\n",
ArgString);
MUISAddData(S,tmpLine);
}
} /* END case mrcmJoin */
break;
break;
case mrcmModify:
{
char EMsg[MMAX_LINE] = {0};
rc = MUIRsvCtlModify(R,RE,EMsg);
MUISAddData(S,EMsg);
if (rc == FAILURE)
{
MUArrayListFree(&RsvList);
return rc;
}
} /* END BLOCK (case mrcmModify) */
break;
case mrcmQuery:
/* NOTE: "profile" handled above */
bmset(&S->Flags,msftReadOnlyCommand);
if (!strcmp(ArgString,"resources"))
{
/* list allocated resources */
if (!MNLIsEmpty(&R->NL))
{
MNLToString(
&R->NL,
bmisset(&Flags,mcmVerbose),
",",
'\0',
tmpLine,
sizeof(tmpLine));
MUISAddData(S,tmpLine);
}
MUArrayListFree(&RsvList);
return(SUCCESS);
} /* END if (!strcmp(ArgString,"resources")) */
else if (!strcmp(ArgString,"export"))
{
mxml_t *DE;
if ((S->SDE == NULL) &&
(MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE))
{
MUISAddData(S,"ERROR: cannot create response\n");
MUArrayListFree(&RsvList);
return(FAILURE);
}
DE = S->SDE;
if (MUIExportRsvQuery(
R,
NULL,
Auth,
DE,
0) == FAILURE)
{
MUArrayListFree(&RsvList);
return(FAILURE);
}
}
else if (!strcmp(ArgString,"wiki"))
{
mstring_t String(MMAX_LINE);
MRsvToWikiString(R,NULL,&String);
MUISAddData(S,String.c_str());
} /* END if (!strcmp(ArgString,"wiki")) */
else
{
/* diagnose/display rsv state/config */
char DiagOpt[MMAX_NAME];
mxml_t *DE = NULL;
mxml_t *RE = NULL;
const enum MRsvAttrEnum RAList[] = {
mraName,
mraAAccount,
mraAGroup,
mraAUser,
mraAQOS,
mraAllocNodeCount,
mraAllocNodeList,
mraAllocProcCount,
mraAllocTaskCount,
mraComment,
mraEndTime,
mraExpireTime,
mraFlags,
mraGlobalID,
mraHostExp,
mraLabel,
mraLogLevel,
mraOwner,
mraPartition,
mraProfile,
mraReqArch,
mraReqFeatureList,
mraReqMemory,
mraReqNodeCount,
mraReqNodeList,
mraReqOS,
mraReqTaskCount,
mraResources,
mraRsvGroup,
mraRsvParent,
mraSID,
mraStartTime,
mraStatCAPS,
mraStatCIPS,
mraStatTAPS,
mraStatTIPS,
mraSubType,
mraTrigger,
mraType,
mraVariables,
mraVMList,
mraNONE };
MUStrCpy(DiagOpt,R->Name,sizeof(DiagOpt));
/* check to see if the socket's return data xml is initialized */
if (S->SDE == NULL)
{
if (MXMLCreateE(&S->SDE,(char *)MSON[msonData]) == FAILURE)
{
MUISAddData(S,"ERROR: cannot create response\n");
MUArrayListFree(&RsvList);
return(FAILURE);
}
}
DE = S->SDE;
MXMLCreateE(&RE,(char *)MXO[mxoRsv]);
MXMLAddE(DE,RE);
MRsvToXML(R,&RE,(enum MRsvAttrEnum *)RAList,NULL,TRUE,mcmNONE);
/* NOTE: do not return, append data to buffer and continue */
} /* END else() */
break;
default:
/* NO-OP */
break;
} /* END switch (CIndex) */
} /* END for (rindex) */
MUArrayListFree(&RsvList);
return(rc);
} /* END MUIRsvCtl() */
int MClassSetAttr(
mclass_t *C, /* I (modified) */
int AIndex, /* I */
void **Value, /* I */
int Format, /* I */
int Mode) /* I */
{
if (C == NULL)
{
return(FAILURE);
}
switch(AIndex)
{
case mclaOCNode:
MUStrDup(&C->OCNodeName,(char *)Value);
break;
case mclaDefReqFeature:
{
/* FORMAT: <FEATURE>[{ \t:,}<FEATURE>]... */
char *ptr;
char *TokPtr;
/* detect default feature requirements */
ptr = MUStrTok((char *)Value,":",&TokPtr);
while (ptr != NULL)
{
MUGetMAttr(eFeature,ptr,mAdd,C->DefFBM,sizeof(C->DefFBM));
ptr = MUStrTok(NULL,":",&TokPtr);
} /* END while (ptr != NULL) */
} /* END BLOCK */
break;
case mclaMaxProcPerNode:
{
int tmpI;
if (Format == mdfString)
tmpI = (int)strtol((char *)Value,NULL,0);
else
tmpI = *(int *)Value;
C->MaxProcPerNode = tmpI;
} /* END BLOCK */
break;
case mclaOCDProcFactor:
{
double tmpD;
if (Format == mdfString)
tmpD = (double)strtod((char *)Value,NULL);
else
tmpD = *(double *)Value;
C->OCDProcFactor = tmpD;
} /* END BLOCK */
break;
case mclaState:
{
int tmpI;
if (Format == mdfString)
tmpI = (int)strtol((char *)Value,NULL,0);
else
tmpI = *(int *)Value;
C->IsDisabled = (tmpI == mjsRunning) ? TRUE : FALSE;
} /* END BLOCK */
break;
case mclaWCOverrun:
{
int tmpL;
if (Format == mdfString)
tmpL = MUTimeFromString((char *)Value);
else
tmpL = *(long *)Value;
C->F.Overrun = tmpL;
} /* END BLOCK */
default:
/* NO-OP */
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch(AIndex) */
return(SUCCESS);
} /* END MClassSetAttr() */
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() */
int MSysDoTest()
{
char *tptr;
char *aptr;
char *ptr;
int aindex;
int rc;
char tmpLine[MMAX_LINE];
const char *TName[] = {
NONE,
"COMPRESS",
"SCHED",
"XML",
"RANGEAND",
"RANGECOLLAPSE",
"RANGEMERGE",
"GETSNRANGE",
"NODEPRIO",
"SPAWN",
"WIKINODE",
"WIKIJOB",
"WIKICLUSTER",
"RMX",
"JOBNAME",
"JOBDIST",
"CHECKSUM",
"LLSUBMIT",
"LLQUERY",
"MAIL",
"PBSPARSE",
"PBSPARSE2",
"NODERANGE",
"BGRANGE",
"ODBCTEST",
"SQLITE3TEST",
"STRINGTEST",
"RMXTEST",
"STATCONVTEST",
"GEOTEST",
"DISATEST",
"MACADDRESS",
NULL };
enum {
mirtNONE = 0,
mirtCompress,
mirtSched,
mirtXML,
mirtRLAND,
mirtJobSelectFRL,
mirtRLMerge,
mirtJobGetSNRange,
mirtNodePrio,
mirtSpawn,
mirtWikiNode,
mirtWikiJob,
mirtWikiCluster,
mirtRMExtension,
mirtJobName,
mirtJobDist,
mirtChecksum,
mirtLLSubmit,
mirtLLQuery,
mirtMail,
mirtPBSParse,
mirtPBSParse2,
mirtNodeRange,
mirtBGRange,
mirtODBCTest,
mirtSQLite3Test,
mirtStringTest,
mirtRMX,
mirtStatConvTest,
mirtGeoTest,
mirtDisaTest,
mirtMacAddress,
mirtLAST };
if ((tptr = getenv(MSCHED_ENVTESTVAR)) == NULL)
{
return(SUCCESS);
}
MUStrCpy(tmpLine,tptr,sizeof(tmpLine));
aindex = MUGetIndexCI(tmpLine,TName,TRUE,0);
aptr = NULL;
if ((ptr = strchr(tmpLine,':')) != NULL)
{
aptr = ptr + 1;
}
fprintf(stderr,"INFO: running test %s, data='%s'\n",
TName[aindex],
(aptr != NULL) ? aptr : "");
switch (aindex)
{
case mirtCompress:
MUCompressTest();
break;
case mirtXML:
__MSysTestXML(aptr);
break;
case mirtRLAND:
__MSysTestRLAND();
break;
case mirtGeoTest:
__MSysTestGeo(aptr);
break;
case mirtJobSelectFRL:
__MSysTestJobSelectFRL();
break;
case mirtRLMerge:
__MSysTestRLMerge();
break;
case mirtJobGetSNRange:
__MSysTestJobGetSNRange();
break;
case mirtMacAddress:
__MSysTestMacAddress();
break;
case mirtNodePrio:
__MSysTestNPrioF();
break;
case mirtSpawn:
__MSysTestSpawn();
break;
case mirtWikiNode:
MWikiTestNode(aptr);
break;
case mirtWikiJob:
MWikiTestJob(aptr);
break;
case mirtWikiCluster:
MWikiTestCluster(aptr);
break;
case mirtRMExtension:
MJobTestRMExtension(aptr);
break;
case mirtJobName:
MJobTestName(aptr);
break;
case mirtChecksum:
MSecTestChecksum(aptr);
break;
case mirtLLSubmit:
{
int JC;
char *ptr;
char *TokPtr = NULL;
mjob_t tmpJ;
mreq_t tmpRQ;
mnode_t *N;
int tmpTM[4];
MRM[0].Type = mrmtLL;
MRM[0].U.LL.ProcVersionNumber = 9;
strcpy(tmpJ.Name,"test");
/* FORMAT: <FROMHOST>.<CLUSTER>,<NODEID> */
ptr = MUStrTok(aptr,".,",&TokPtr);
tmpJ.SubmitHost = NULL;
MUStrDup(&tmpJ.SubmitHost,ptr);
ptr = MUStrTok(NULL,".,",&TokPtr);
ptr = MUStrTok(NULL,",",&TokPtr);
if (MNodeAdd(ptr,&N) == FAILURE)
{
exit(1);
}
N->RM = &MRM[0];
tmpJ.TaskMap = tmpTM;
tmpJ.TaskMapSize = 4;
tmpJ.TaskMap[0] = N->Index;
tmpJ.TaskMap[1] = -1;
tmpJ.Req[0] = &tmpRQ;
tmpJ.Req[1] = NULL;
tmpRQ.RMIndex = 0;
MRMWorkloadQuery(&JC,NULL,NULL,NULL);
MRMJobStart(&tmpJ,NULL,NULL);
exit(1);
} /* END BLOCK (case mirtLLSubmit) */
break;
case mirtLLQuery:
/* NYI */
exit(1);
break;
case mirtMail:
rc = MSysSendMail(
MSysGetAdminMailList(1),
NULL,
"moab test",
NULL,
"test mail");
if (rc == FAILURE)
exit(1);
exit(0);
break;
case mirtPBSParse:
case mirtPBSParse2:
{
/* NOTE: select must be translated different than "neednodes", if select is specified,
memory is assigned as a per task resource and arch as a per req constraint */
/*
> qsub -l select=4 (it requests 4 default chunks)
>
> or
>
> qsub -l select=2:ncpus=1:mem=10GB+3:ncpus=2:mem=8GB:arch=linux
> (requests 2 chunks of 1 cpu,10gb of mem and 3 chunks of
> 2 cpus, 8gb of mem, arch=linux).
*/
int rc;
mjob_t *J = NULL;
int *TaskList = NULL;
MRM[0].Type = mrmtPBS;
MJobMakeTemp(&J);
MRMJobPreLoad(J,"PBSParse",&MRM[0]);
TaskList = (int *)MUMalloc(sizeof(int) * MSched.JobMaxTaskCount);
if (aindex == mirtPBSParse)
rc = MJobGetPBSTaskList(J,aptr,TaskList,FALSE,TRUE,FALSE,FALSE,NULL,NULL);
else
rc = MJobGetSelectPBSTaskList(J,aptr,TaskList,FALSE,FALSE,NULL);
MUFree((char **)TaskList);
if (rc == FAILURE)
{
exit(1);
}
exit(0);
} /* END BLOCK (case mirtPBSParse) */
break;
case mirtNodeRange:
{
int nindex;
mnode_t *N;
mnl_t tmpNL;
MNLInit(&tmpNL);
nindex = 0;
MNodeAdd("node12",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node11",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node03",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node04",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 2);
MNodeAdd("node05",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 2);
MNodeAdd("node06",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 1);
MNodeAdd("node09",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node08",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node07",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node10",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 3);
MNodeAdd("node01",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 4);
MNodeAdd("node02",&N);
MNLSetNodeAtIndex(&tmpNL,nindex,N);
MNLSetTCAtIndex(&tmpNL,nindex++, 3);
MNLTerminateAtIndex(&tmpNL,nindex);
mstring_t TaskBuf(MMAX_BUFFER);
MUNLToRangeString(
&tmpNL,
NULL,
-1,
TRUE,
TRUE,
&TaskBuf);
fprintf(stderr,"Range: '%s'\n",
TaskBuf.c_str());
exit(0);
} /* END BLOCK */
break;
case mirtBGRange:
{
char tmpLine[MMAX_LINE];
int NCount;
int NListIndex = 0;
char **NCharList = NULL; /* make dynamic */
NCharList = (char **)MUCalloc(1,sizeof(char *) * MSched.M[mxoNode]);
snprintf(tmpLine,sizeof(tmpLine),"002x233,702x733");
MUParseBGRangeString(tmpLine,NCharList,MSched.M[mxoNode] - NListIndex,&NCount);
exit(0);
}
break;
case mirtDisaTest:
rc = MDISATest();
exit((rc == SUCCESS) ? 0 : 1);
break;
default:
{
int tindex;
/* cannot determine test */
fprintf(stderr,"ERROR: invalid test specified (%s) - use ",
tptr);
for (tindex = 1;tindex < mirtLAST;tindex++)
{
fprintf(stderr,"%s%s",
(tindex > 1) ? "," : "",
TName[tindex]);
}
fprintf(stderr,"\n");
} /* END BLOCK */
exit(1);
/*NOTREACHED*/
break;
} /* END switch (aindex) */
return(SUCCESS);
} /* END MSysDoTest() */
int MTrigQuery(
mtrig_t *T, /* I */
char *Attr, /* I */
mbool_t DoGlobal) /* I */
{
if (T == NULL)
{
return(FAILURE);
}
switch (T->OType)
{
case mxoRsv:
{
mrsv_t *R;
mrsv_t *tmpR;
char *ptr;
char *TokPtr = NULL;
char *tmpVar;
char *BPtr = NULL;
int BSpace = 0;
char *Label;
char AllHostList[MMAX_BUFFER];
char tmpBuf[MMAX_BUFFER];
char tmpName[MMAX_NAME];
char Action[MMAX_NAME];
marray_t RList;
int rindex;
enum MRsvAttrEnum AIndex;
R = (mrsv_t *)T->O;
if (R == NULL)
{
return(FAILURE);
}
MUArrayListCreate(&RList,sizeof(mrsv_t *),10);
MRsvGroupGetList(R->RsvGroup,&RList,NULL,0);
if (RList.NumItems <= 0)
{
T->State = mtsSuccessful;
MUArrayListFree(&RList);
return(SUCCESS);
}
MUStrCpy(Action,Attr,sizeof(Action));
MUSNInit(&BPtr,&BSpace,AllHostList,sizeof(AllHostList));
/* FORMAT: <ATTR>=<VALUE> */
Label = MUStrTok(Action,":",&TokPtr);
ptr = MUStrTok(NULL," =\n\t",&TokPtr);
tmpVar = MUStrTok(NULL," \n\t",&TokPtr);
AIndex = (enum MRsvAttrEnum)MUGetIndexCI(ptr,MRsvAttr,FALSE,mraNONE);
for (rindex = 0;rindex < RList.NumItems;rindex++)
{
tmpR = (mrsv_t *)MUArrayListGetPtr(&RList,rindex);
/* all error checking done above */
if ((tmpR->Label == NULL) || strcmp(Label,tmpR->Label))
continue;
switch (AIndex)
{
case mraAllocNodeList:
if (MNLToString(&tmpR->NL,FALSE,",",'\0',tmpBuf,sizeof(tmpBuf)) == SUCCESS)
{
if (rindex == 0)
{
snprintf(tmpName,sizeof(tmpName),"%s-HOSTLIST",
Label);
}
else
{
snprintf(tmpName,sizeof(tmpName),"%s-HOSTLIST-%d",
Label,
rindex);
}
if (rindex == 0)
MUSNCat(&BPtr,&BSpace,tmpBuf);
else
MUSNPrintF(&BPtr,&BSpace,",%s",tmpBuf);
MTrigAddVariable(T,tmpName,0,tmpBuf,TRUE);
}
break;
case mraReqOS:
if (tmpR->ReqOS != 0)
{
if (rindex == 0)
{
snprintf(tmpName,sizeof(tmpName),"%s-OS",Label);
}
else
{
snprintf(tmpName,sizeof(tmpName),"%s-OS-%d",Label,rindex);
}
MUStrCpy(tmpBuf,MAList[meOpsys][tmpR->ReqOS],sizeof(tmpBuf));
MTrigAddVariable(T,tmpName,0,tmpBuf,TRUE);
}
break;
case mraVariables:
{
mln_t *tmpL;
mln_t *Head;
char *vptr;
if (tmpVar == NULL)
break;
/* search variable lists for tmpVar */
if (!strncasecmp(tmpVar,"owner.",strlen("owner.")))
{
switch (tmpR->OType)
{
case mxoUser:
case mxoGroup:
case mxoAcct:
Head = ((mgcred_t *)tmpR->O)->Variables;
vptr = &tmpVar[strlen("owner.")];
break;
default:
Head = NULL;
vptr = NULL;
break;
}
}
else
{
Head = tmpR->Variables;
vptr = tmpVar;
}
if (vptr == NULL)
{
break;
}
if (MULLCheck(Head,vptr,&tmpL) == SUCCESS)
{
snprintf(tmpName,sizeof(tmpName),"%s-%s",Label,vptr);
MUStrCpy(tmpBuf,(char *)tmpL->Ptr,sizeof(tmpBuf));
MTrigAddVariable(T,tmpName,0,tmpBuf,TRUE);
}
else if (&tmpR->NL != NULL)
{
char *VarValue = NULL;
mnode_t *N = MNLReturnNodeAtIndex(&tmpR->NL,0);
if (MUHTGet(&N->Variables,vptr,(void **)&VarValue,NULL) == SUCCESS)
{
snprintf(tmpName,sizeof(tmpName),"%s-%s",Label,vptr);
MUStrCpy(tmpBuf,VarValue,sizeof(tmpBuf));
MTrigAddVariable(T,tmpName,0,tmpBuf,TRUE);
}
} /* END else if (tmpR->NL != NULL) */
} /* END BLOCK mraVariables */
break;
default:
/* NYI */
break;
} /* END switch (AIndex) */
} /* END for (rindex) */
switch (AIndex)
{
case mraAllocNodeList:
snprintf(tmpName,sizeof(tmpName),"%s-HOSTLIST",Label);
MTrigAddVariable(T,tmpName,0,AllHostList,TRUE);
break;
default:
/* NYI */
break;
} /* END switch (AIndex) */
MUArrayListFree(&RList);
} /* END case mxoRsv */
break;
case mxoJob:
break;
default:
break;
} /* END switch (T->OType) */
T->State = mtsSuccessful;
return(SUCCESS);
} /* END MTrigQuery() */
int MTrigDoModifyAction(
mtrig_t *T, /* I */
char *ModString, /* I (modified) */
char *EMsg) /* I (optional minsize==MMAX_LINE) */
{
void *O = NULL;
enum MXMLOTypeEnum OType;
char *OID = NULL;
char *Attr;
char *Value;
char *ptr;
char *TokPtr = NULL;
int AIndex;
char tmpEMsg[MMAX_LINE];
enum MStatusCodeEnum SC;
mbool_t OListSpecified = FALSE;
const char *FName = "MTrigDoModifyAction";
MDB(3,fRM) MLog("%s(%s,%s)\n",
FName,
(T != NULL) ? T->TName : "NULL",
(ModString != NULL) ? ModString : "NULL");
if (EMsg != NULL)
EMsg[0] = '\0';
if (T == NULL)
{
return(FAILURE);
}
if ((ModString == NULL) || (ModString[0] == '\0'))
{
return(SUCCESS);
}
if (strchr(ModString,'=') == NULL)
{
/* FORMAT: {set|incr|decr} <OTYPE> <OID> <ATTR> <VALUE> */
if ((ptr = MUStrTok(ModString," \t\n",&TokPtr)) == NULL)
{
return(FAILURE);
}
if ((ptr = MUStrTok(NULL," \t\n",&TokPtr)) == NULL)
{
return(FAILURE);
}
OType = (enum MXMLOTypeEnum)MUGetIndexCI(ptr,MXO,FALSE,mSet);
if ((OID = MUStrTok(NULL," \t\n",&TokPtr)) == NULL)
{
return(FAILURE);
}
if (strchr(OID,',') != NULL)
OListSpecified = TRUE;
if ((Attr = MUStrTok(NULL," \t\n",&TokPtr)) == NULL)
{
return(FAILURE);
}
Value = TokPtr;
if (OListSpecified == FALSE)
{
if (MOGetObject(OType,OID,&O,mVerify) == FAILURE)
{
/* unable to locate object */
if (EMsg != NULL)
{
snprintf(EMsg,MMAX_LINE,"ERROR: unable to locate %s:%s",
MXO[OType],
OID);
}
return(FAILURE);
}
}
else
{
O = NULL;
}
}
else
{
/* FORMAT: <ATTR>=<VALUE> */
OType = T->OType;
OID = T->OID;
Attr = MUStrTok(ModString,"=",&TokPtr);
Value = TokPtr;
if (Attr == NULL)
{
return(FAILURE);
}
}
switch (OType)
{
case mxoNode:
/* only supports OS and NodeState for now */
AIndex = MUGetIndexCI(Attr,MNodeAttr,FALSE,mnaNONE);
if ((AIndex != mnaOS) && (AIndex != mnaNodeState))
{
if (EMsg != NULL)
{
snprintf(EMsg,MMAX_LINE,"WARNING: cannot modify node attribute %s",
MNodeAttr[AIndex]);
}
return(FAILURE);
}
if (MNodeModify(
(mnode_t *)O,
(OListSpecified == TRUE) ? OID : NULL,
(enum MNodeAttrEnum)AIndex,
Value,
tmpEMsg,
&SC) == FAILURE)
{
MDB(2,fRM) MLog("WARNING: cannot modify node %s, %s\n",
OID,
tmpEMsg);
if (EMsg != NULL)
{
snprintf(EMsg,MMAX_LINE,"WARNING: cannot modify node %s, %s",
OID,
tmpEMsg);
}
return(FAILURE);
}
break;
case mxoRsv:
AIndex = MUGetIndexCI(Attr,MRsvAttr,FALSE,mraNONE);
if (MRsvSetAttr(
(mrsv_t *)T->O,
(enum MRsvAttrEnum)AIndex,
Value,
mdfString,
mSet) == FAILURE)
{
return(FAILURE);
}
break;
case mxoxVPC:
AIndex = MUGetIndexCI(Attr,MParAttr,FALSE,mpaNONE);
if (MParSetAttr(
(mpar_t *)T->O,
(enum MParAttrEnum)AIndex,
(void **)Value,
mdfString,
mSet) == FAILURE)
{
return(FAILURE);
}
break;
default:
/* object modification not supported */
if (EMsg != NULL)
snprintf(EMsg,MMAX_LINE,"ERROR: object modification not supported");
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (OType) */
return(SUCCESS);
} /* END MTrigDoModifyAction() */
int MTrigParseInternalAction(
char *ActionString,
enum MXMLOTypeEnum *OType,
char *OID, /* MMAX_BUFFER */
char *Action, /* MMAX_LINE */
char *ArgLine, /* MMAX_LINE */
char *Msg) /* MMAX_LINE */
{
/* FORMAT: <OTYPE>:<OID>:<ACTION>:<context information> */
char *ptr;
char *TokPtr = NULL;
char *tmpAString = NULL;
const char *FName = "MTrigPraseInternalAction";
MDB(4,fSCHED) MLog("%s(%s,OType,OID,Action,ArgLine,,Msg)\n",
FName,
(ActionString != NULL) ? ActionString : "NULL");
if (Msg != NULL)
Msg[0] = '\0';
if ((ActionString == NULL) || (OType == NULL) || (OID == NULL) || (Action == NULL) || (ArgLine == NULL))
{
if (Msg != NULL)
strcpy(Msg,"internal error");
return(FAILURE);
}
OID[0] = '\0';
Action[0] = '\0';
ArgLine[0] = '\0';
MUStrDup(&tmpAString,ActionString);
/* NOTE: this format and parsing is duplicated in MTrigCheckInternalAction()
any update here must be copied to that routine */
ptr = MUStrTok(tmpAString,":",&TokPtr);
if (ptr == NULL)
{
if (Msg != NULL)
strcpy(Msg,"invalid action");
MUFree(&tmpAString);
return(FAILURE);
}
*OType = (enum MXMLOTypeEnum)MUGetIndexCI(ptr,MXO,FALSE,mxoNONE);
if (*OType == mxoNONE)
{
MDB(4,fSCHED) MLog("ERROR: invalid object type '%s' in %s\n",
ptr,
FName);
if (Msg != NULL)
strcpy(Msg,"invalid object type");
MUFree(&tmpAString);
return(FAILURE);
}
ptr = MUStrTok(NULL,":",&TokPtr);
if (ptr == NULL)
{
MDB(4,fSCHED) MLog("ERROR: cannot extract object ID in %s\n",
FName);
if (Msg != NULL)
strcpy(Msg,"invalid object id");
MUFree(&tmpAString);
return(FAILURE);
}
MUStrCpy(OID,ptr,MMAX_BUFFER);
ptr = MUStrTok(NULL,":",&TokPtr);
if (ptr == NULL)
{
MDB(4,fSCHED) MLog("ERROR: cannot parse action in %s\n",
FName);
if (Msg != NULL)
strcpy(Msg,"cannot locate action");
MUFree(&tmpAString);
return(FAILURE);
}
MUStrCpy(Action,ptr,MMAX_LINE);
if ((TokPtr != NULL) && (TokPtr[0] != '\0'))
MUStrCpy(ArgLine,TokPtr,MMAX_LINE);
else
ArgLine[0] = '\0';
MUFree(&tmpAString);
return(SUCCESS);
} /* END MTrigParseInternalAction() */
int MTrigSetFlags(
mtrig_t *T,
char *Buf)
{
char *vptr;
int vindex;
char UBuf[MMAX_LINE];
if ((T == NULL) || (Buf == NULL))
{
return(FAILURE);
}
MUStrCpy(UBuf,Buf,sizeof(UBuf));
MUStrToLower(UBuf);
for (vindex = 0;MTrigFlag[vindex] != NULL;vindex++)
{
if ((vptr = strstr(UBuf,MTrigFlag[vindex])) && (vptr != NULL))
{
switch (vindex)
{
case mtfUser:
{
char *ptr;
char *TokPtr;
char tmpLine[MMAX_LINE];
bmset(&T->SFlags,vindex);
if (strchr(vptr,'+') == NULL)
break;
MUStrCpy(tmpLine,vptr,sizeof(tmpLine));
ptr = MUStrTok(tmpLine,"[] \t\n:,|.",&TokPtr);
if (ptr != NULL)
{
vptr = strchr(ptr,'+');
if ((vptr == NULL) || (vptr[1] == '\0'))
break;
MUStrDup(&T->UserName,&vptr[1]);
}
}
break;
case mtfGlobalVars:
{
char *ptr;
char *TokPtr;
char tmpLine[MMAX_LINE];
bmset(&T->SFlags,vindex);
if (strchr(vptr,'+') == NULL)
break;
MUStrCpy(tmpLine,vptr,sizeof(tmpLine));
ptr = MUStrTok(tmpLine,"[] \t\n:,|.",&TokPtr);
if (ptr != NULL)
{
vptr = strchr(ptr,'+');
if ((vptr == NULL) || (vptr[1] == '\0'))
break;
MUStrDup(&T->GetVars,&vptr[1]);
}
}
break;
case mtfMultiFire:
bmset(&T->SFlags,vindex);
bmset(&T->InternalFlags,mtifMultiFire);
break;
case mtfGenericSysJob:
case mtfSoftKill:
case mtfCleanup:
case mtfInterval:
case mtfProbe:
case mtfProbeAll:
case mtfAttachError:
case mtfRemoveStdFiles:
case mtfResetOnModify:
case mtfCheckpoint:
case mtfObjectXMLStdin:
case mtfAsynchronous:
bmset(&T->SFlags,vindex);
break;
default:
/* NO-OP */
break;
}
}
} /* END for (vindex) */
return(SUCCESS);
} /* END MTrigSetFlags() */
int MVMFromXML(
mvm_t *VM,
mxml_t *E)
{
int aindex;
enum MVMAttrEnum vaindex;
if ((VM == NULL) || (E == NULL))
{
return(FAILURE);
}
for (aindex = 0;aindex < E->ACount;aindex++)
{
vaindex = (enum MVMAttrEnum)MUGetIndex(E->AName[aindex],MVMAttr,FALSE,0);
if (vaindex == mvmaNONE)
continue;
switch (vaindex)
{
case mvmaVariables:
case mvmaMigrateCount:
case mvmaLastMigrateTime:
case mvmaLastSubState:
case mvmaLastSubStateMTime:
case mvmaStorageRsvNames:
case mvmaEffectiveTTL:
case mvmaSpecifiedTTL:
case mvmaStartTime:
MVMSetAttr(VM,vaindex,(void **)E->AVal[aindex],mdfString,mSet);
break;
case mvmaAlias:
{
/* Aliases are comma delimited in the checkpoint file
MVMSetAttr expects one at a time */
char tmpLine[MMAX_LINE];
char *ptr;
char *TokPtr;
MUStrCpy(tmpLine,E->AVal[aindex],sizeof(tmpLine));
ptr = MUStrTok(tmpLine,",",&TokPtr);
while (ptr != NULL)
{
MVMSetAttr(VM,vaindex,(void **)ptr,mdfString,mAdd);
ptr = MUStrTok(NULL,",",&TokPtr);
}
} /* END BLOCK mvmaAlias */
break;
default:
MVMSetAttr(VM,vaindex,(void **)E->AVal[aindex],mdfString,mSet);
break;
}
} /* END for (aindex = 0;...) */
/* Parse remaining children (triggers, storage, variables, etc.) */
for (aindex = 0;aindex < E->CCount;aindex++)
{
if (!strcmp(E->C[aindex]->Name,"trig"))
{
mtrig_t *TPtr = NULL;
TPtr = (mtrig_t *)MUMalloc(sizeof(mtrig_t));
memset(TPtr,0,sizeof(mtrig_t));
bmset(&TPtr->InternalFlags,mtifIsAlloc);
MTrigFromXML(TPtr,E->C[aindex]);
MTrigInitialize(TPtr);
}
else if (!strcasecmp(E->C[aindex]->Name,"Variables"))
{
MVMVarsFromXML(VM,E->C[aindex]);
}
else if (!strcasecmp(E->C[aindex]->Name,"action"))
{
MVMActionFromXML(VM,E->C[aindex]);
}
else
{
/* NOTE: function will check to make sure child is of type "storage" */
MVMStorageMountFromXML(VM,E->C[aindex]);
}
}
return(SUCCESS);
} /* END MVMFromXML() */
int MRsvExpandClassExpression(
char *Expression,
marray_t *NodeList,
mpar_t *P)
{
char *ptr2;
char *TokPtr2 = NULL;
mclass_t *C;
mnode_t *N;
int nindex;
mbool_t inlist = FALSE;
MASSERT(Expression != NULL, "NULL Expression pointer expanding Class Expression");
MASSERT(P != NULL, "NULL Partition pointer expanding Class Expression");
ptr2 = MUStrTok(Expression,":",&TokPtr2);
ptr2 = MUStrTok(NULL,",:",&TokPtr2); /* get class value string */
while(ptr2 != NULL)
{
int cindex;
if (MClassFind(ptr2,&C) == FAILURE)
{
/* requested class not located */
ptr2 = MUStrTok(NULL,",:",&TokPtr2); /* Get next class name*/
continue;
}
for (nindex = 0;nindex < MSched.M[mxoNode];nindex++)
{
N = MNode[nindex];
if (N == NULL)
break;
if (!bmisset(&N->Classes,C->Index))
{
/* requested class not on node */
continue;
}
/* If a partition was specified and the node is not on the specified partition then continue */
if ((P->Index != 0) && (N->PtIndex != P->Index))
{
/* requested partition not on node */
continue;
}
/* Make sure the node is not already in the list due to multiple class membership. */
inlist = FALSE;
for (cindex = 0;cindex < NodeList->NumItems; cindex++)
{
mnode_t *tmpN = (mnode_t *)MUArrayListGetPtr(NodeList,cindex);
if (tmpN == N)
{
/* Node is already in the list */
inlist = TRUE;
break;
}
}
if (inlist == FALSE)
{
MUArrayListAppendPtr(NodeList,N);
}
} /* END for (nindex = 0;nindex < MSched.M[mxoNode];nindex++) */
ptr2 = MUStrTok(NULL, ",:", &TokPtr2); /* Get next class name*/
} /* END while(ptr2 != NULL) */
return(NodeList->NumItems);
} /* END int MRsvExpandClassExpression()*/
int MVMSetAttr(
mvm_t *VM, /* I * (modified) */
enum MVMAttrEnum AIndex, /* I */
void const *Value, /* I */
enum MDataFormatEnum Format, /* I */
enum MObjectSetModeEnum Mode) /* I */
{
const char *FName = "MVMSetAttr";
char const *ValAsString = (char const *)Value;
MDB(6,fSTRUCT) MLog("%s(%s,%s,Value,%s,%s)\n",
FName,
(VM != NULL) ? VM->VMID : "NULL",
MVMAttr[AIndex],
MFormatMode[Format],
MObjOpType[Mode]);
if (VM == NULL)
{
return(FAILURE);
}
switch (AIndex)
{
case mvmaActiveOS:
{
int OS = MUMAGetIndex(meOpsys,ValAsString,mSet);
if (OS != 0)
VM->ActiveOS = OS;
/*TODO: what if OS is not in VM's OSList? */
}
break;
case mvmaADisk:
VM->ARes.Disk = strtol(ValAsString,NULL,0);
break;
case mvmaAlias:
{
if (Mode != mClear)
{
mvoid_t *Element;
if (MUHTGet(&MNetworkAliasesHT,ValAsString,NULL,NULL) == SUCCESS)
{
/* Specified alias is already in use. Do not allow */
return(FAILURE);
}
/* Add to table now */
/* Done as mvoid_t so that node aliases work as well */
Element = (mvoid_t *)MUCalloc(1,sizeof(mvoid_t));
Element->Ptr = (void *)VM;
Element->PtrType = mxoxVM;
MUStrCpy(Element->Name,VM->VMID,sizeof(Element->Name));
MUHTAdd(&MNetworkAliasesHT,ValAsString,(void *)Element,NULL,MUFREE);
}
if ((Mode == mSet) || (Mode == mClear))
{
/* Clear list, remove from global table */
mln_t *freePtr = NULL;
while (MULLIterate(VM->Aliases,&freePtr) == SUCCESS)
{
MUHTRemove(&MNetworkAliasesHT,freePtr->Name,MUFREE);
}
/* TODO: send out signal to outside system to free alias */
MULLFree(&VM->Aliases,MUFREE);
}
if ((Mode == mSet) || (Mode == mAdd))
{
/* Set has already been cleared, treat as add */
/* These must be added one at a time */
if (VM->Aliases == NULL)
{
MULLCreate(&VM->Aliases);
}
if (MULLAdd(&VM->Aliases,ValAsString,NULL,NULL,MUFREE) == FAILURE)
return(FAILURE);
/* TODO: send out signal to outside system to set alias */
}
} /* END BLOCK mvmaAlias */
break;
case mvmaAMem:
VM->ARes.Mem = strtol(ValAsString,NULL,0);
break;
case mvmaAProcs:
/* NOTE: set ARes.Procs to 0 if VM is not available */
if (MNSISUP(VM->State) && (VM->State != mnsUnknown))
{
VM->ARes.Procs = strtol(ValAsString,NULL,0);
}
else
{
VM->ARes.Procs = 0;
}
break;
case mvmaCDisk:
VM->CRes.Disk = strtol(ValAsString,NULL,0);
break;
case mvmaCMem:
VM->CRes.Mem = strtol(ValAsString,NULL,0);
break;
case mvmaCProcs:
VM->CRes.Procs = strtol(ValAsString,NULL,0);
break;
case mvmaCPULoad:
VM->CPULoad = strtod(ValAsString,NULL);
break;
case mvmaDescription:
MUStrDup(&VM->Description,ValAsString);
break;
case mvmaEffectiveTTL:
VM->EffectiveTTL = strtol(ValAsString,NULL,10);
break;
case mvmaFlags:
bmfromstring((char *)Value,MVMFlags,&VM->Flags);
break;
case mvmaGMetric:
{
char *GMTok;
char *GMName;
char *GMVal;
char *TokPtr = NULL;
char *TokPtr2 = NULL;
int gmindex;
/* generic metrics */
/* FORMAT: <GMETRIC>{:=}<VAL>[,<GMETRIC>{:=}<VAL>]... */
GMTok = MUStrTok((char *)Value,", \t\n",&TokPtr);
while (GMTok != NULL)
{
GMName = MUStrTok(GMTok,"=:",&TokPtr2);
GMVal = MUStrTok(NULL,"=:",&TokPtr2);
GMTok = MUStrTok(NULL,", \t\n",&TokPtr);
if ((GMName == NULL) || (GMVal == NULL))
{
/* mal-formed value, ignore */
continue;
}
gmindex = MUMAGetIndex(meGMetrics,GMName,mAdd);
if ((gmindex <= 0) || (gmindex >= MSched.M[mxoxGMetric]))
continue;
/* valid gmetric located */
MVMSetGMetric(VM,gmindex,GMVal);
} /* END while (GMTok != NULL) */
} /* END BLOCK (case mvmaGMetric) */
break;
case mvmaID:
MUStrCpy(VM->VMID,ValAsString,sizeof(VM->VMID));
break;
case mvmaLastMigrateTime:
VM->LastMigrationTime = (mulong)strtol(ValAsString,NULL,10);
break;
case mvmaLastSubState:
MUStrDup(&VM->LastSubState,ValAsString);
break;
case mvmaLastSubStateMTime:
VM->LastSubStateMTime = (mulong)strtol(ValAsString,NULL,10);
break;
case mvmaMigrateCount:
VM->MigrationCount = (int)strtol(ValAsString,NULL,10);
break;
case mvmaNextOS:
{
int OS = MUMAGetIndex(meOpsys,ValAsString,mSet);
if (OS != 0)
VM->NextOS = OS;
/*TODO: what if OS is not in VM's OSList? */
}
case mvmaNodeTemplate:
case mvmaOSList:
case mvmaSlotIndex:
case mvmaState:
break;
case mvmaSovereign:
{
mbool_t WasSovereign = bmisset(&VM->Flags,mvmfSovereign);
mbool_t NewVal = MUBoolFromString(ValAsString,FALSE);
if (NewVal == TRUE)
bmset(&VM->Flags,mvmfSovereign);
else
bmunset(&VM->Flags,mvmfSovereign);
if ((!bmisset(&VM->Flags,mvmfSovereign)) && (WasSovereign == TRUE))
{
if (VM->J != NULL)
{
/* is this how to handle previously sovereign VMs correctly? */
bmset(&VM->J->IFlags,mjifCancel);
}
}
}
break;
case mvmaSpecifiedTTL:
VM->SpecifiedTTL = strtol(ValAsString,NULL,10);
break;
case mvmaStartTime:
VM->StartTime = (mulong)strtol(ValAsString,NULL,10);
break;
case mvmaSubState:
if (ValAsString == NULL)
{
MUFree(&VM->SubState);
}
else
{
MUStrDup(&VM->SubState,(char *)ValAsString);
}
break;
case mvmaStorageRsvNames:
MUStrDup(&VM->StorageRsvNames,(char *)ValAsString);
break;
case mvmaVariables:
if (Mode == mSet)
{
/* Clear the current attrs */
MUHTClear(&VM->Variables,TRUE,(mfree_t)MUFree);
}
/* FORMAT: attr:value[+attr:value]... */
/* value is a string (alphanumeric and '_') */
if ((Mode == mAdd) || (Mode == mSet))
{
char *ptr;
char *TokPtr = NULL;
char *TokPtr2 = NULL;
ptr = MUStrTok((char *)ValAsString,"+",&TokPtr);
while (ptr != NULL)
{
char *AName;
char *AVal;
char *MallocVal = NULL;
char ANameNoQuotes[MMAX_LINE];
AName = MUStrTok(ptr,":",&TokPtr2);
AVal = MUStrTok(NULL,":",&TokPtr2);
MUStrReplaceStr(AName,"\"","",ANameNoQuotes,sizeof(ANameNoQuotes));
if (AVal != NULL)
{
int AValLen = (strlen(AVal) * sizeof(char)) + 1;
MallocVal = (char *)MUMalloc(AValLen);
MUStrReplaceStr(AVal,"\"","",MallocVal,strlen(AVal) + 1);
}
MUHTAdd(&VM->Variables,ANameNoQuotes,(void *)MallocVal,NULL,MUFREE);
ptr = MUStrTok(NULL,"+",&TokPtr);
} /* END while (ptr != NULL) */
} /* END if ((Mode == mAdd) || (Mode == mSet)) */
break;
case mvmaTrigger:
if (Format == mdfString)
{
mtrig_t *T;
marray_t TList;
int tindex;
MUArrayListCreate(&TList,sizeof(mtrig_t *),10);
if (MTrigLoadString(
&VM->T,
(char *)Value,
TRUE,
FALSE,
mxoxVM,
VM->VMID,
&TList,
NULL) == FAILURE)
{
return(FAILURE);
}
for (tindex = 0; tindex < TList.NumItems;tindex++)
{
T = (mtrig_t *)MUArrayListGetPtr(&TList,tindex);
if (MTrigIsValid(T) == FALSE)
continue;
MTrigInitialize(T);
MOAddTrigPtr(&VM->T,T);
} /* END for (tindex) */
return(SUCCESS);
} /* END if (Format == mdfString) */
/* END BLOCK mvmaTrigger */
break;
case mvmaNONE:
case mvmaLAST:
default:
break;
} /* END switch (AIndex) */
return(SUCCESS);
} /* END MVMSetAttr() */
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 MTrigLaunchInternalAction(
mtrig_t *T, /* I (optional) */
char *ActionString, /* I */
mbool_t *Complete, /* O */
char *Msg) /* O (optional,minsize=MMAX_LINE) */
{
/* FORMAT: <OTYPE>:<OID>:<ACTION>:<context information> */
char *ptr = NULL;
char *TokPtr = NULL;
char *tmpAString = NULL;
char ArgLine[MMAX_LINE*10];
char OID[MMAX_BUFFER];
char Action[MMAX_LINE*10];
enum MXMLOTypeEnum OType;
const char *FName = "MTrigLaunchInternalAction";
MDB(4,fSCHED) MLog("%s(%s,%s,Msg)\n",
FName,
((T != NULL) && (T->TName != NULL)) ? T->TName : "NULL",
(ActionString != NULL) ? ActionString : "NULL");
if (Msg != NULL)
Msg[0] = '\0';
if (Complete != NULL)
*Complete = TRUE;
if (ActionString == NULL)
{
if (Msg != NULL)
strcpy(Msg,"internal error");
return(FAILURE);
}
MUStrDup(&tmpAString,ActionString);
/* NOTE: this format and parsing is duplicated in MTrigCheckInternalAction()
any update here must be copied to that routine */
ptr = MUStrTok(tmpAString,":",&TokPtr);
if (ptr == NULL)
{
MDB(4,fSCHED) MLog("ERROR: invalid action");
if (Msg != NULL)
strcpy(Msg,"invalid action");
MUFree(&tmpAString);
return(FAILURE);
}
OType = (enum MXMLOTypeEnum)MUGetIndexCI(ptr,MXO,FALSE,mxoNONE);
if (OType == mxoNONE)
{
MDB(4,fSCHED) MLog("ERROR: invalid object type '%s' in %s\n",
ptr,
FName);
if (Msg != NULL)
strcpy(Msg,"invalid object type");
MUFree(&tmpAString);
return(FAILURE);
}
ptr = MUStrTok(NULL,":",&TokPtr);
if (ptr == NULL)
{
MDB(4,fSCHED) MLog("ERROR: cannot extract object ID in %s\n",
FName);
if (Msg != NULL)
strcpy(Msg,"invalid object id");
MUFree(&tmpAString);
return(FAILURE);
}
MUStrCpy(OID,ptr,sizeof(OID));
ptr = MUStrTok(NULL,":",&TokPtr);
if (ptr == NULL)
{
MDB(4,fSCHED) MLog("ERROR: cannot parse action in %s\n",
FName);
if (Msg != NULL)
strcpy(Msg,"cannot locate action");
MUFree(&tmpAString);
return(FAILURE);
}
MUStrCpy(Action,ptr,sizeof(Action));
if ((TokPtr != NULL) && (TokPtr[0] != '\0'))
MUStrCpy(ArgLine,TokPtr,sizeof(ArgLine));
else
ArgLine[0] = '\0';
MUFree(&tmpAString);
switch (OType)
{
case mxoJob:
{
mjob_t *J;
char *JID;
char *TokPtr;
/* OID FORMAT: <JID>[+<JID>]... */
mbool_t FailureDetected;
enum MJobCtlCmdEnum atype;
atype = (enum MJobCtlCmdEnum)MUGetIndexCI(Action,MJobCtlCmds,FALSE,mjcmNONE);
if (atype == mjcmNONE)
{
MDB(4,fSCHED) MLog("ERROR: cannot parse job action '%s' in %s\n",
Action,
FName);
return(FAILURE);
}
FailureDetected = FALSE;
JID = MUStrTok(OID,"+",&TokPtr);
while (JID != NULL)
{
if (!strcmp(JID,"-"))
{
if (T == NULL)
return(FAILURE);
J = (mjob_t *)T->O;
}
else if (MJobFind(JID,&J,mjsmExtended) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot locate job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
switch (atype)
{
case mjcmCancel:
{
char *CCodeCheck;
char UpperArgLine[MMAX_LINE];
MDB(7,fSCHED) MLog(" INFO: Job flaged for cancel by trigger action. '%s' in %s\n",
JID,
FName);
bmset(&J->IFlags, mjifCancel);
MUStrToUpper(ArgLine,UpperArgLine,MMAX_LINE);
/* If specified, allow trigger to set the completion code of the job */
if ((CCodeCheck = strstr(UpperArgLine,"CCODE=")) != NULL)
{
CCodeCheck += strlen("CCODE="); /* Skip the "CCODE:" part */
if (CCodeCheck[0] != '\0')
{
J->CompletionCode = strtol(CCodeCheck,NULL,10);
}
}
else
{
J->CompletionCode = 273; /* Completion code for a canceled job in TORQUE */
}
} /* END case mjcmCancel */
break;
case mjcmComplete:
{
char *CCodeCheck;
char UpperArgLine[MMAX_LINE];
if ((!bmisset(&J->Flags,mjfSystemJob) &&
!bmisset(&J->Flags,mjfNoRMStart)))
{
MDB(4,fSCHED) MLog("ERROR: job %s in bad state for complete in %s\n",
J->Name,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
/* the next three lines set the WCLimit to the exact runtime
* this also causes MS3WorkloadQuery to remove the job */
J->SpecWCLimit[0] = MSched.Time - J->StartTime;
J->SpecWCLimit[1] = MSched.Time - J->StartTime;
J->WCLimit = MSched.Time - J->StartTime;
if (MJOBISACTIVE(J) == TRUE)
{
MRsvJCreate(J,NULL,J->StartTime,mjrActiveJob,NULL,FALSE); /* just removes active rsv? */
}
MUStrToUpper(ArgLine,UpperArgLine,MMAX_LINE);
if ((CCodeCheck = strstr(UpperArgLine,"CCODE=")) != NULL)
{
CCodeCheck += strlen("CCODE="); /* Skip the "CCODE:" part */
if (CCodeCheck[0] != '0')
{
J->CompletionCode = strtol(CCodeCheck,NULL,10);
}
}
/* MSched.TrigCompletedJob = TRUE; -- not sure why we wanted to skip the UI phase here... */
} /* END BLOCK (case mjcmComplete) */
break;
case mjcmModify:
{
char *TokPtr;
char *Attr = NULL;
char *Value = NULL;
char *Msg = NULL;
enum MJobAttrEnum aindex;
enum MObjectSetModeEnum Op;
if (strstr(ArgLine,"+="))
Op = mAdd;
else if (strstr(ArgLine,"-="))
Op = mDecr;
else
Op = mSet;
Attr = MUStrTok(ArgLine,"+-=",&TokPtr);
Value = MUStrTok(NULL,"=: \t\n",&TokPtr);
Msg = MUStrTok(NULL,":\t\n",&TokPtr); /* extract message */
aindex = (enum MJobAttrEnum)MUGetIndexCI(Attr,MJobAttr,FALSE,mnaNONE);
switch (aindex)
{
case mjaHold:
if (MJobSetAttr(J,mjaHold,(Value != NULL) ? (void **)Value : (void **)"batch",mdfString,mSet) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot hold job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
if (Msg != NULL)
{
/* attach provided message */
MMBAdd(
&J->MessageBuffer,
Msg,
NULL,
mmbtHold,
0,
0,
NULL);
}
if (MJOBISACTIVE(J))
{
/* Set to idle but don't clear DRM and DRMJID */
MJobToIdle(J,FALSE,FALSE);
J->SubState = mjsstNONE;
}
/* checkpoint change (make this configurable at this point?) */
MOCheckpoint(mxoJob,(void *)J,FALSE,NULL);
break;
case mjaVariables:
{
char tmpLine[MMAX_LINE*2];
snprintf(tmpLine,sizeof(tmpLine),"%s=%s",
Value,
Msg);
if (MJobSetAttr(J,mjaVariables,(void **)tmpLine,mdfString,Op) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot set trigvar job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
} /* END BLOCK */
break;
default:
if (!strcasecmp(Attr,"gres"))
{
if ((Op == mAdd) &&
(MJobAddRequiredGRes(
J,
Value,
1,
mxaGRes,
FALSE,
FALSE) == SUCCESS))
{
/* SUCCESS - NO-OP */
}
else if ((Op == mDecr) &&
(MJobRemoveGRes(J,Value,TRUE) == SUCCESS))
{
/* SUCCESS -- Do Nothing */
}
else
{
MDB(4,fSCHED) MLog("ERROR: cannot adjust gres for job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
}
else
{
MDB(4,fSCHED) MLog("ERROR: cannot modify attribute '%s' for job '%s' in %s\n",
Attr,
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
break;
}
} /* END BLOCK (case mjcmModify) */
break;
case mjcmSignal:
{
char EMsg[MMAX_LINE];
int SC;
if (MRMJobSignal(J,-1,ArgLine,EMsg,&SC) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot send signal '%s' to job '%s' in %s\n",
ArgLine,
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
} /* END BLOCK (case mjcmSignal) */
break;
case mjcmStart:
/* FIXME: check reservation, check allocation */
{
J->SubState = mjsstNONE;
/* set "copy-tasklist" flag */
bmset(&J->IFlags,mjifCopyTaskList);
if (MRMJobStart(J,NULL,NULL) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot start job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
J->State = mjsRunning;
} /* END BLOCK (case mjcmStart) */
break;
case mjcmRequeue:
/* FIXME: check reservation, check allocation */
{
char EMsg[MMAX_LINE];
J->SubState = mjsstNONE;
/* set "copy-tasklist" flag */
if (MJobRequeue(J,NULL,"workflow failure",EMsg,NULL) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot requeue job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
J->State = mjsIdle;
} /* END BLOCK (case mjcmStart) */
default:
MDB(4,fSCHED) MLog("ERROR: action '%s' not handled in %s\n",
Action,
FName);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (atype) */
JID = MUStrTok(NULL,"+",&TokPtr);
} /* END while (JID != NULL) */
if (FailureDetected == TRUE)
{
return(FAILURE);
}
} /* END BLOCK (case mxoJob) */
break;
case mxoNode:
{
enum MNodeCtlCmdEnum atype;
char *rsvProfile = NULL;
atype = (enum MNodeCtlCmdEnum)MUGetIndexCI(Action,MNodeCtlCmds,FALSE,mncmNONE);
if (!strcasecmp(Action,"reserve"))
{
char tmpLine[MMAX_LINE];
snprintf(tmpLine,sizeof(tmpLine),"auto-trigger-rsv.%s",
T->TName);
if (ArgLine[0] != '\0')
{
char *Attr = MUStrTok(ArgLine,"=",&TokPtr);
char *Value = MUStrTok(NULL,"= \t\n",&TokPtr);
if ((Attr != NULL) &&
(strncasecmp(Attr,"rsvprofile",strlen("rsvprofile")) == 0))
rsvProfile = Value;
}
if (T->OType != mxoRsv)
{
MNodeReserve(
(mnode_t *)T->O,
MCONST_EFFINF,
tmpLine,
rsvProfile,
"Reservation created by trigger");
return(SUCCESS);
}
else
{
return(FAILURE);
}
}
else if ((!strcasecmp(Action,"evacvms")) && (MSched.AllowVMMigration == TRUE))
{
/* Evacuate all vms on nodes held by this reservation */
char tmpMsg[MMAX_LINE];
int rc = SUCCESS;
mnl_t NL;
MNLInit(&NL);
MNLFromString(OID,&NL,1,FALSE);
rc = MNodeEvacVMsMultiple(&NL);
MNLFree(&NL);
/* Write out events */
snprintf(tmpMsg,sizeof(tmpMsg),"attempting to migrate vms from node '%s' for evacvms reservation '%s' (TID: %s)",
OID,
((mrsv_t *)T->O)->Name,
(T->TName != NULL) ? T->TName : "NULL");
MDB(5,fSTRUCT) MLog("INFO: %s\n",
tmpMsg);
return(rc);
} /* END if (!strcasecmp(Action,"evacvms")) */
if (atype == mncmNONE)
{
return(FAILURE);
}
switch (atype)
{
case mncmModify:
if (MSched.AggregateNodeActions == FALSE)
{
char *ptr;
char *TokPtr;
mnode_t *N;
char *Attr;
char *Value;
enum MNodeAttrEnum aindex;
/* always look on the bright side of life */
mbool_t NodeModifySuccessDetected;
/* FORMAT: <ARG>=<VALUE> */
Attr = MUStrTok(ArgLine,"=",&TokPtr);
Value = MUStrTok(NULL,"= \t\n",&TokPtr);
aindex = (enum MNodeAttrEnum)MUGetIndexCI(Attr,MNodeAttr,FALSE,mnaNONE);
NodeModifySuccessDetected = FALSE;
/* FORMAT: OID = node[,node]... */
ptr = MUStrTok(OID,",",&TokPtr);
if ((ptr == NULL) || (aindex == mnaNONE))
{
MDB(4,fSCHED) MLog("ERROR: unknown attribute to modify on node '%s'\n",
Attr);
return(FAILURE);
}
while (ptr != NULL)
{
if (MNodeFind(ptr,&N) == FAILURE)
{
ptr = MUStrTok(NULL,",",&TokPtr);
continue;
}
switch (aindex)
{
case mnaOS:
{
char EMsg[MMAX_LINE];
if (!strcmp(Value,MAList[meOpsys][0]))
{
if ((N->PowerSelectState == mpowOff) &&
(MNodeSetAttr(N,mnaPowerIsEnabled,(void **)"true",mdfString,mVerify) == FAILURE))
{
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
/* do not return failure just because one provisioning job fails */
}
}
else if (MNodeProvision(N,NULL,NULL,Value,TRUE,EMsg,NULL) == FAILURE)
{
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
/* do not return failure just because one provisioning job fails */
}
else
{
NodeModifySuccessDetected = TRUE;
}
}
break;
case mnaPowerIsEnabled:
/* NOTE: do not return failure just because node modify fails
* the routine will fail if all node modifies fail */
if (!strcmp(Value,"on"))
{
/* power node on */
if (MNodeSetAttr(N,mnaPowerIsEnabled,(void **)"true",mdfString,mVerify) == SUCCESS)
{
NodeModifySuccessDetected = TRUE;
}
}
else if (!strcasecmp(Value,"off"))
{
/* power node off */
if (MNodeSetAttr(N,mnaPowerIsEnabled,(void **)"false",mdfString,mVerify) == SUCCESS)
{
NodeModifySuccessDetected = TRUE;
}
}
else if (!strcasecmp(Value,"reset"))
{
char EMsg[MMAX_LINE];
/* reset node */
if (MNodeReboot(N,NULL,EMsg,NULL) == FAILURE)
{
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
}
else
{
NodeModifySuccessDetected = TRUE;
}
}
else if (!strcasecmp(Value,"on+"))
{
/* power node on, but trigger isn't finished until action is complete */
if (Complete != NULL)
*Complete = FALSE;
if (T != NULL)
MUStrDup(&T->CompleteAction,ActionString);
MNodeSetAttr(N,mnaPowerIsEnabled,(void **)"true",mdfString,mVerify);
T->PID = 1;
}
else if (!strcasecmp(Value,"off+"))
{
/* power node off, but trigger isn't finished until action is complete */
if (T != NULL)
MUStrDup(&T->CompleteAction,ActionString);
if (Complete != NULL)
*Complete = FALSE;
MNodeSetAttr(N,mnaPowerIsEnabled,(void **)"false",mdfString,mVerify);
T->PID = 1;
}
break;
default:
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (aindex) */
ptr = MUStrTok(NULL,",",&TokPtr);
} /* END while (ptr != NULL) */
/* if none of the node modify requests (non-aggregating) succeeded,
then return failure. (success just means it was submitted
at this stage) */
if ((aindex == mnaOS) &&
(NodeModifySuccessDetected == FALSE))
{
return (FAILURE);
}
} /* END if (MSched.AggregateNodeActions == FALSE) */
else
{
mnl_t NL;
char *Attr;
char *Value;
enum MNodeAttrEnum aindex;
int nindex;
/* FORMAT: <ARG>=<VALUE> */
Attr = MUStrTok(ArgLine,"=",&TokPtr);
Value = MUStrTok(NULL,"= \t\n",&TokPtr);
aindex = (enum MNodeAttrEnum)MUGetIndexCI(Attr,MNodeAttr,FALSE,mnaNONE);
/* FORMAT: OID = node[,node]... */
if (aindex == mnaNONE)
{
return(FAILURE);
}
MNLInit(&NL);
MNLFromString(OID,&NL,-1,FALSE);
/* NOTE: in the node aggregating case, return failure when there is an error
* performing node modify operations (e.g. communicating with the RM) */
switch (aindex)
{
case mnaNodeState:
{
enum MStatusCodeEnum SC;
char EMsg[MMAX_LINE];
if (MNodeModify(NULL,OID,mnaNodeState,Value,EMsg,&SC) == FAILURE)
{
MDB(2,fRM) MLog("WARNING: cannot modify state of '%s' = %s\n",
OID,
EMsg);
return(FAILURE);
}
} /* END case mnaNodeState */
break;
case mnaOS:
{
char EMsg[MMAX_LINE];
if (MNLGetemReady(&NL,Value,EMsg) == FAILURE)
{
/* NYI: append EMsg to Msg */
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
MNLFree(&NL);
return (FAILURE);
}
} /* END BLOCK case mnaOS */
break;
case mnaPowerIsEnabled:
{
mnode_t *N;
for (nindex = 0;MNLGetNodeAtIndex(&NL,nindex,&N) == SUCCESS;nindex++)
{
if (N == MSched.GN)
continue;
if ((!strcasecmp(Value,"on")) ||
(!strcasecmp(Value,"on+")))
{
/* power node on */
if ((N->PowerSelectState == mpowOn) ||
(MNodeGetSysJob(N,msjtPowerOn,MBNOTSET,NULL) == SUCCESS))
{
/* skip this node */
MDB(5,fSCHED) MLog("INFO: not powering node '%s' on--power select state is already 'ON'\n",
N->Name);
MNLRemove(&NL,N);
continue;
}
}
else if ((!strcasecmp(Value,"off")) ||
(!strcasecmp(Value,"off+")))
{
/* power node off */
if ((N->PowerSelectState == mpowOff) ||
(MNodeGetSysJob(N,msjtPowerOff,TRUE,NULL) == SUCCESS))
{
/* skip this node */
MDB(5,fSCHED) MLog("INFO: not powering node '%s' off--power select state is already 'OFF'\n",
N->Name);
MNLRemove(&NL,N);
continue;
}
}
} /* END for (nindex) */
} /* END BLOCK */
if (!strcmp(Value,"on"))
{
/* power node on */
if (MNLSetAttr(&NL,mnaPowerIsEnabled,(void **)"true",mdfString,mVerify) == FAILURE)
{
MNLFree(&NL);
return (FAILURE);
}
}
else if (!strcasecmp(Value,"off"))
{
/* power node off */
if (MNLSetAttr(&NL,mnaPowerIsEnabled,(void **)"false",mdfString,mVerify) == FAILURE)
{
MNLFree(&NL);
return (FAILURE);
}
}
else if (!strcasecmp(Value,"reset"))
{
char EMsg[MMAX_LINE];
/* reset node */
if (MNodeReboot(NULL,&NL,EMsg,NULL) == FAILURE)
{
MNLFree(&NL);
/* NYI: append EMsg to Msg */
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
return (FAILURE);
}
}
else if (!strcasecmp(Value,"on+"))
{
/* power node on, but trigger isn't finished until action is complete */
if (MNLSetAttr(&NL,mnaPowerIsEnabled,(void **)"true",mdfString,mVerify) == FAILURE)
{
MNLFree(&NL);
if (Complete != NULL)
*Complete = TRUE;
return(FAILURE);
}
if (Complete != NULL)
*Complete = FALSE;
if (T != NULL)
MUStrDup(&T->CompleteAction,ActionString);
T->PID = 1;
}
else if (!strcasecmp(Value,"off+"))
{
/* power node off, but trigger isn't finished until action is complete */
if (MNLSetAttr(&NL,mnaPowerIsEnabled,(void **)"false",mdfString,mVerify) == FAILURE)
{
MNLFree(&NL);
if (Complete != NULL)
*Complete = TRUE;
return(FAILURE);
}
if (Complete != NULL)
*Complete = FALSE;
if (T != NULL)
MUStrDup(&T->CompleteAction,ActionString);
T->PID = 1;
}
break;
default:
MNLFree(&NL);
return (FAILURE);
/*NOTREACHED*/
break;
} /* END switch (aindex) */
} /* END else */
break;
case mncmCreate:
{
int rc;
mnode_t *N;
char EMsg[MMAX_LINE];
char tmpLine[MMAX_LINE*10];
/* FORMAT: COUNT:OS */
if (MNodeFind(OID,&N) == FAILURE)
{
if (Msg != NULL)
snprintf(Msg,MMAX_LINE,"cannot locate hostlist '%s'",OID);
return(FAILURE);
}
/* FORMAT: COUNT:OS */
snprintf(tmpLine,sizeof(tmpLine),"%s:%s%s%s",
N->Name,
ArgLine,
((T->OType == mxoJob) && ((mjob_t *)T->O != NULL)) ? ":operationid=" : "",
((T->OType == mxoJob) && ((mjob_t *)T->O != NULL)) ? ((mjob_t *)T->O)->Name : "");
mstring_t Output(MMAX_LINE);
rc = MRMVMCreate(tmpLine,&Output,EMsg,NULL);
if (rc == FAILURE)
{
if (Msg != NULL)
MUStrCpy(Msg,EMsg,MMAX_LINE);
MUStrCpy(Msg,Output.c_str(),MMAX_LINE);
}
return(rc);
} /* END BLOCK (case mncmCreate) */
break;
case mncmMigrate:
{
int rc;
char *TokPtr = ArgLine;
char *VMName;
char *SrcNodeName;
char *DestNodeName;
mnode_t *SrcNode;
mnode_t *DestNode;
mln_t *VMLink;
char *VMList[2];
mnl_t DestNL;
/* FORMAT: <VM>:<DestNode>,... */
TokPtr = ArgLine;
VMName = MUStrTok(NULL,":=",&TokPtr);
DestNodeName = MUStrTok(NULL,":=",&TokPtr);
SrcNodeName = OID;
if ((DestNodeName == NULL) || (VMName == NULL) ||(SrcNodeName) == NULL)
{
return(FAILURE);
}
if (MNodeFind(SrcNodeName,&SrcNode) == FAILURE)
{
return(FAILURE);
}
if (MNodeFind(DestNodeName,&DestNode) == FAILURE)
{
return(FAILURE);
}
if (MULLCheck(SrcNode->VMList,VMName,&VMLink) == FAILURE)
{
/* Should we be checking this here? */
/* return(FAILURE); */
}
MNLInit(&DestNL);
VMList[0] = VMName;
MNLSetNodeAtIndex(&DestNL,0,DestNode);
MNLSetTCAtIndex(&DestNL,0,1);
MNLTerminateAtIndex(&DestNL,1);
VMList[1] = NULL;
rc = MRMJobMigrate((mjob_t *)T->O,VMList,&DestNL,Msg,NULL);
MNLFree(&DestNL);
return(rc);
} /* END BLOCK (case mncmMigrateVM) */
break;
default:
return(FAILURE);
/*NOTREACHED*/
break;
}
} /* END BLOCK (case mxoNode) */
break;
case mxoxJobGroup:
{
job_iter JTI;
marray_t JArray;
int jindex;
mjob_t *J;
char *JID;
char *ptr;
char *TokPtr;
/* OID FORMAT: <JID>[+<JID>]... */
mbool_t FailureDetected;
enum MJobCtlCmdEnum atype;
char *Attr = NULL;
char *Value = NULL;
char *Msg = NULL;
enum MJobAttrEnum aindex = mjaNONE;
atype = (enum MJobCtlCmdEnum)MUGetIndexCI(Action,MJobCtlCmds,FALSE,mjcmNONE);
if (atype == mjcmNONE)
{
MDB(4,fSCHED) MLog("ERROR: cannot parse job action '%s' in %s\n",
Action,
FName);
return(FAILURE);
}
if (atype == mjcmModify)
{
char *TokPtr;
Attr = MUStrTok(ArgLine,"+-=",&TokPtr);
Value = MUStrTok(NULL,"=: \t\n",&TokPtr);
Msg = MUStrTok(NULL,":\t\n",&TokPtr); /* extract message */
aindex = (enum MJobAttrEnum)MUGetIndexCI(Attr,MJobAttr,FALSE,mnaNONE);
}
FailureDetected = FALSE;
JID = MUStrTok(OID,"+",&TokPtr);
while (JID != NULL)
{
MUArrayListCreate(&JArray,sizeof(mjob_t *),1);
if (!strcmp(JID,"-"))
{
if (T == NULL)
return(FAILURE);
ptr = T->OID;
}
else
{
ptr = JID;
}
MJobIterInit(&JTI);
while (MJobTableIterate(&JTI,&J) == SUCCESS)
{
if ((J->JGroup != NULL) && (J->JGroup->Name != NULL) && (!strcmp(ptr,J->JGroup->Name)))
{
MUArrayListAppend(&JArray,&J);
}
}
if (MUArrayListGet(&JArray,0) == NULL)
{
MDB(4,fSCHED) MLog("ERROR: cannot locate job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
for (jindex = 0;jindex < JArray.NumItems;jindex++)
{
J = *(mjob_t **)MUArrayListGet(&JArray,jindex);
if (J == NULL)
continue;
switch (atype)
{
case mjcmCancel:
{
char *CCodeCheck;
char UpperArgLine[MMAX_LINE];
if (MJobCancel(J,NULL,FALSE,Msg,NULL) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot cancel job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
MUStrToUpper(ArgLine,UpperArgLine,MMAX_LINE);
/* If specified, allow trigger to set the completion code of the job */
if ((CCodeCheck = strstr(UpperArgLine,"CCODE=")) != NULL)
{
CCodeCheck += strlen("CCODE="); /* Skip the "CCODE:" part */
if (CCodeCheck[0] != '\0')
{
J->CompletionCode = strtol(CCodeCheck,NULL,10);
}
}
else
{
J->CompletionCode = 273; /* Completion code for a canceled job in TORQUE */
}
} /* END case mjcmCancel */
break;
case mjcmModify:
switch (aindex)
{
case mjaHold:
if (MJobSetAttr(
J,
mjaHold,
(Value != NULL) ? (void **)Value : (void **)"batch",
mdfString,
mSet) == FAILURE)
{
MDB(4,fSCHED) MLog("ERROR: cannot hold job '%s' in %s\n",
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
if (Msg != NULL)
{
/* attach provided message */
MMBAdd(
&J->MessageBuffer,
Msg,
NULL,
mmbtHold,
0,
0,
NULL);
}
if (J->SubState == mjsstProlog)
{
J->SubState = mjsstNONE;
}
/* checkpoint change (make this configurable at this point?) */
MOCheckpoint(mxoJob,(void *)J,FALSE,NULL);
break;
default:
MDB(4,fSCHED) MLog("ERROR: cannot modify attribute '%s' for job '%s' in %s\n",
Attr,
JID,
FName);
JID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
break;
} /* END switch (aindex) */
break;
default:
MDB(4,fSCHED) MLog("ERROR: action '%s' not handled in %s\n",
Action,
FName);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (atype) */
} /* END for (jindex) */
JID = MUStrTok(NULL,"+",&TokPtr);
MUArrayListFree(&JArray);
} /* END while (JID != NULL) */
if (FailureDetected == TRUE)
{
return(FAILURE);
}
} /* END BLOCK (case mxoxJobGroup) */
break;
case mxoSched:
{
enum MSchedCtlCmdEnum atype;
atype = (enum MSchedCtlCmdEnum)MUGetIndexCI(Action,MSchedCtlCmds,FALSE,msctlNONE);
switch (atype)
{
case msctlVMMigrate:
{
enum MVMMigrationPolicyEnum aindex;
aindex = (enum MVMMigrationPolicyEnum)MUGetIndexCI(ArgLine,MVMMigrationPolicy,FALSE,mvmmmNONE);
return(MUIVMCtlPlanMigrations(aindex,FALSE,FALSE,NULL));
}
default:
return(FAILURE);
} /* END switch (atype) */
} /* END case mxoSched */
break;
case mxoTrig:
{
enum MSchedCtlCmdEnum atype;
atype = (enum MSchedCtlCmdEnum)MUGetIndexCI(Action,MSchedCtlCmds,FALSE,msctlNONE);
if (atype == msctlNONE)
{
return(FAILURE);
}
switch (atype)
{
case msctlModify:
{
char *TokPtr;
mtrig_t *T;
char *Attr;
char *Value;
enum MTrigAttrEnum aindex;
Attr = MUStrTok(ArgLine,"=",&TokPtr);
Value = MUStrTok(NULL,"\"",&TokPtr);
/* FORMAT: OID = trigid */
aindex = (enum MTrigAttrEnum)MUGetIndexCI(Attr,MTrigAttr,FALSE,mtaNONE);
if ((OID == NULL) || (OID[0] == '\0') || (aindex == mtaNONE))
{
return(FAILURE);
}
if (MTrigFind(OID,&T) == FAILURE)
{
return(FAILURE);
}
switch (aindex)
{
case mtaActionData:
if (MTrigSetAttr(T,aindex,Value,mdfString,mSet) == FAILURE)
{
return(FAILURE);
}
break;
default:
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (aindex) */
break;
} /* END case msctlModify */
default:
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (atype) */
} /* END BLOCK (case mxoTrig) */
break;
case mxoRM:
{
mrm_t *R = NULL;
char *RMID;
char *TokPtr;
mbool_t FailureDetected;
enum MRMCtlCmdEnum atype;
atype = (enum MRMCtlCmdEnum)MUGetIndexCI(Action,MRMCtlCmds,FALSE,mrmctlNONE);
if (atype == mrmctlNONE)
{
MDB(4,fSCHED) MLog("ERROR: cannot parse rm action '%s' in %s\n",
Action,
FName);
return(FAILURE);
}
FailureDetected = FALSE;
RMID = MUStrTok(OID,"+",&TokPtr);
while (RMID != NULL)
{
if (!strcmp(RMID, "-"))
{
if (T == NULL)
return(FAILURE);
R = (mrm_t *)T->O;
}
else if (MRMFind(RMID,&R) == FAILURE)
{
if (Msg != NULL)
strcpy(Msg,"cannot locate specified RM");
RMID = MUStrTok(NULL,"+",&TokPtr);
FailureDetected = TRUE;
continue;
}
switch (atype)
{
case mrmctlModify:
{
char *TokPtr;
enum MRMAttrEnum aindex;
char *Attr;
char *Value;
/* FORMAT: <attr>=<value> */
Attr = MUStrTok(ArgLine,"=",&TokPtr);
Value = MUStrTok(NULL,"\"",&TokPtr);
aindex = (enum MRMAttrEnum)MUGetIndexCI(Attr,MRMAttr,FALSE,mrmaNONE);
switch (aindex)
{
case mrmaState:
return(MRMSetAttr(R,aindex,(void **)Value,mdfString,mSet));
break;
default:
if (Msg != NULL)
strcpy(Msg,"cannot modify specified attribute");
return(FAILURE);
/* NOTREACHED */
break;
} /* END switch (aindex) */
} /* END BLOCK (case mrmctlModify) */
break;
case mrmctlDestroy:
MDB(3,fUI) MLog("WARNING: cannot destroy static RM\n");
if (Msg != NULL)
strcpy(Msg,"WARNING: cannot destroy static RM\n");
return(FAILURE);
/* NOTREACHED */
break;
case mrmctlPurge:
return(MRMPurge(R));
break;
default:
if (Msg != NULL)
strcpy(Msg,"action not supported for RM object");
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (atype) */
RMID = MUStrTok(NULL,"+",&TokPtr);
} /* END while (RMID != NULL */
if (FailureDetected == TRUE)
{
return(FAILURE);
}
} /* END BLOCK (case mxoRM) */
break;
case mxoRsv:
{
enum MRsvCtlCmdEnum atype;
atype = (enum MRsvCtlCmdEnum)MUGetIndexCI(Action,MRsvCtlCmds,FALSE,mrcmNONE);
if (atype == mrcmNONE)
{
return(FAILURE);
}
switch (atype)
{
case mrcmModify:
{
char *ptr;
char *TokPtr;
enum MRsvAttrEnum attr;
mrsv_t *R;
if (!strcmp(OID,"-"))
{
if (T == NULL)
return(FAILURE);
R = (mrsv_t *)T->O;
}
else if (MRsvFind(OID,&R,mraNONE) == FAILURE)
{
return(FAILURE);
}
ptr = MUStrTok(ArgLine,":",&TokPtr);
attr = (enum MRsvAttrEnum)MUGetIndexCI(ptr,MRsvAttr,FALSE,mraNONE);
switch (attr)
{
case mraACL:
{
enum MObjectSetModeEnum Mode;
if (MUStrIsEmpty(TokPtr))
Mode = mSet;
else if (strstr(TokPtr,"-=") != NULL)
Mode = mDecr;
else if (strstr(TokPtr,"+=") != NULL)
Mode = mAdd;
else
Mode = mSet;
MRsvSetAttr(R,mraACL,(void *)TokPtr,mdfString,Mode);
}
break;
default:
return(FAILURE);
/*NOTREACHED*/
break;
}
} /* END case mrcmModify */
break;
case mrcmDestroy:
{
mrsv_t *R;
if (!strcmp(OID,"-"))
{
if (T == NULL)
return(FAILURE);
R = (mrsv_t *)T->O;
}
else if (MRsvFind(OID,&R,mraNONE) == FAILURE)
{
return(FAILURE);
}
R->CancelIsPending = TRUE;
R->EndTime = MSched.Time - 1;
R->ExpireTime = 0;
/* remove reservation */
MRsvCheckStatus(NULL);
if ((long)R->StartTime <= MUIDeadLine)
{
/* adjust UI phase wake up time */
if (MSched.AdminEventAggregationTime >= 0)
MUIDeadLine = MIN(MUIDeadLine,(long)MSched.Time + MSched.AdminEventAggregationTime);
}
} /* END case mrcmDestroy */
break;
case mrcmOther:
{
mrsv_t *R;
if (!strcmp(OID,"-"))
{
if (T == NULL)
{
return(FAILURE);
}
R = (mrsv_t *)T->O;
}
else if (MRsvFind(OID,&R,mraNONE) == FAILURE)
{
return(FAILURE);
}
/* parse argline */
if (strstr(ArgLine,"submit") != NULL)
{
MJobSubmitFromJSpec(R->SpecJ,NULL,Msg);
} /* END if (strstr(ArgLine,"submit") != NULL) */
} /* END BLOCK (case mrcmOther) */
break;
default:
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (atype) */
} /* END BLOCK (case mxoRsv) */
break;
case mxoxVPC:
{
mpar_t *VPC;
MVPCFind(OID,&VPC,TRUE);
if (!strcasecmp(Action,"destroy"))
{
MVPCDestroy(&VPC,ArgLine);
}
else
{
return(FAILURE);
}
} /* END case mxoxVPC */
break;
default:
if (Msg != NULL)
strcpy(Msg,"unsupported trigger object type");
return(FAILURE);
/* NOTREACHED */
break;
} /* END switch (OType) */
/*NOTE: return may (and does) return in above switch statement */
return(SUCCESS);
} /* END MTrigLaunchInternalAction() */
int MUStringToE(
char *TimeLine,
long *EpochTime)
{
char Second[MAX_MNAME];
char Minute[MAX_MNAME];
char Hour[MAX_MNAME];
char Day[MAX_MNAME];
char Month[MAX_MNAME];
char Year[MAX_MNAME];
char TZ[MAX_MNAME];
char StringTime[MAX_MNAME];
char StringDate[MAX_MNAME];
char Line[MAX_MLINE];
char *ptr;
char *tail;
struct tm Time;
struct tm *DefaultTime;
time_t ETime; /* calculated epoch time */
time_t Now;
int YearVal;
char *TokPtr;
const char *FName = "MUStringToE";
DBG(2,fCONFIG) DPrint("%s(%s,EpochTime)\n",
FName,
TimeLine);
time(&Now);
/* check 'NOW' keyword */
if (!strcmp(TimeLine,"NOW"))
{
*EpochTime = (long)Now;
return(SUCCESS);
}
/* check 'OFF' keyword */
if (!strcmp(TimeLine,"OFF"))
{
*EpochTime = MAX_MTIME;
return(SUCCESS);
}
if ((ptr = strchr(TimeLine,'+')) != NULL)
{
/* using relative time */
/* Format [ +d<DAYS> ][ +h<HOURS> ][ +m<MINUTES> ][ +s<SECONDS> ] */
ETime = Now + MUTimeFromString(ptr + 1);
}
else
{
/* using absolute time */
/* Format: HH[:MM[:SS]][_MM[/DD[/YY]]] */
setlocale(LC_TIME,"en_US.iso88591");
DefaultTime = localtime(&Now);
/* copy default values into time structure */
strcpy(Second,"00");
strcpy(Minute,"00");
strftime(Hour ,MAX_MNAME,"%H",DefaultTime);
strftime(Day ,MAX_MNAME,"%d",DefaultTime);
strftime(Month ,MAX_MNAME,"%m",DefaultTime);
strftime(Year ,MAX_MNAME,"%Y",DefaultTime);
strftime(TZ ,MAX_MNAME,"%Z",DefaultTime);
if ((tail = strchr(TimeLine,'_')) != NULL)
{
/* time and date specified */
strncpy(StringTime,TimeLine,(tail - TimeLine));
StringTime[(tail - TimeLine)] = '\0';
strcpy(StringDate,(tail + 1));
DBG(7,fCONFIG) DPrint("INFO: time: '%s' date: '%s'\n",
StringTime,
StringDate);
/* parse date */
if ((ptr = MUStrTok(StringDate,"/",&TokPtr)) != NULL)
{
strcpy(Month,ptr);
if ((ptr = MUStrTok(NULL,"/",&TokPtr)) != NULL)
{
strcpy(Day,ptr);
if ((ptr = MUStrTok(NULL,"/",&TokPtr)) != NULL)
{
YearVal = atoi(ptr);
if (YearVal < 97)
{
sprintf(Year,"%d",
YearVal + 2000);
}
else if (YearVal < 1900)
{
sprintf(Year,"%d",
YearVal + 1900);
}
else
{
sprintf(Year,"%d",
YearVal);
}
}
}
}
}
else
{
strcpy(StringTime,TimeLine);
}
/* parse time */
if ((ptr = MUStrTok(StringTime,":_",&TokPtr)) != NULL)
{
strcpy(Hour,ptr);
if ((ptr = MUStrTok(NULL,":_",&TokPtr)) != NULL)
{
strcpy(Minute,ptr);
if ((ptr = MUStrTok(NULL,":_",&TokPtr)) != NULL)
strcpy(Second,ptr);
}
}
/* create time string */
sprintf(Line,"%s:%s:%s %s/%s/%s %s",
Hour,
Minute,
Second,
Month,
Day,
Year,
TZ);
/* perform bounds checking */
if ((atoi(Second) > 59) ||
(atoi(Minute) > 59) ||
(atoi(Hour) > 23) ||
(atoi(Month) > 12) ||
(atoi(Day) > 31) ||
(atoi(Year) > 2097))
{
DBG(1,fCONFIG) DPrint("ERROR: invalid time specified '%s' (bounds exceeded)\n",
Line);
return(FAILURE);
}
memset(&Time,0,sizeof(Time));
Time.tm_hour = atoi(Hour);
Time.tm_min = atoi(Minute);
Time.tm_sec = atoi(Second);
Time.tm_mon = atoi(Month) - 1;
Time.tm_mday = atoi(Day);
Time.tm_year = atoi(Year) - 1900;
/* adjust for TZ */
Time.tm_isdst = -1;
/* place current time into tm structure */
DBG(5,fCONFIG) DPrint("INFO: generated time line: '%s'\n",
Line);
/* strptime(Line,"%T %m/%d/%Y %Z",&Time); */
if ((ETime = mktime(&Time)) == -1)
{
DBG(5,fCONFIG) DPrint("ERROR: cannot determine epoch time for '%s', errno: %d (%s)\n",
Line,
errno,
strerror(errno));
return(FAILURE);
}
} /* END else (strchr(TimeLine,'+')) */
DBG(3,fCONFIG) DPrint("INFO: current epoch: %lu time: %s\n",
(unsigned long)Now,
ctime(&Now));
DBG(3,fCONFIG) DPrint("INFO: calculated epoch: %lu time: %s\n",
(unsigned long)ETime,
ctime(&ETime));
*EpochTime = (long)ETime;
return(SUCCESS);
} /* END MUStringToE() */
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() */
long MUTimeFromString(
char *TString)
{
long val;
char *ptr1;
char *ptr2;
char *ptr3;
char *ptr4;
char *TokPtr;
char Line[MAX_MLINE];
const char *FName = "MUTimeFromString";
DBG(2,fCONFIG) DPrint("%s(%s)\n",
FName,
(TString != NULL) ? TString : "NULL");
if (TString == NULL)
return(0);
if (!strcmp(TString,"INFINITY"))
return(MAX_MTIME);
if (strchr(TString,':') == NULL)
{
/* line specified as 'raw' seconds */
val = strtol(TString,NULL,0);
DBG(4,fCONFIG) DPrint("INFO: string '%s' specified as seconds\n",
TString);
return(val);
}
else if (strchr(TString,'_') != NULL)
{
/* line specified as 'absolute' time */
MUStringToE(TString,&val);
DBG(4,fCONFIG) DPrint("INFO: string '%s' specified as absolute time\n",
TString);
return(val);
}
/* line specified in 'military' time */
MUStrCpy(Line,TString,sizeof(Line));
ptr1 = NULL;
ptr2 = NULL;
ptr3 = NULL;
ptr4 = NULL;
if ((ptr1 = MUStrTok(Line,":",&TokPtr)) != NULL)
{
if ((ptr2 = MUStrTok(NULL,":",&TokPtr)) != NULL)
{
if ((ptr3 = MUStrTok(NULL,":",&TokPtr)) != NULL)
{
ptr4 = MUStrTok(NULL,":",&TokPtr);
}
}
}
if (ptr1 == NULL)
{
DBG(4,fCONFIG) DPrint("INFO: cannot read string '%s'\n",
TString);
return(0);
}
if (ptr4 == NULL)
{
/* adjust from HH:MM:SS to DD:HH:MM:SS notation */
ptr4 = ptr3;
ptr3 = ptr2;
ptr2 = ptr1;
ptr1 = NULL;
}
val = (((ptr1 != NULL) ? atoi(ptr1) : 0) * 86400) +
(((ptr2 != NULL) ? atoi(ptr2) : 0) * 3600) +
(((ptr3 != NULL) ? atoi(ptr3) : 0) * 60) +
(((ptr4 != NULL) ? atoi(ptr4) : 0) * 1);
DBG(4,fCONFIG) DPrint("INFO: string '%s' -> %ld\n",
TString,
val);
return(val);
} /* END MUTimeFromString() */
int MRMJobValidate(
mjob_t *J, /* I */
mrm_t *R, /* I */
char *EMsg, /* O (optional,minsize=MMAX_LINE) */
enum MJobCtlCmdEnum *FailureAction, /* I (optional) */
int *SC) /* O (optional) */
{
enum MWJobAttrEnum aindex;
enum MRMSubTypeEnum SType;
int index;
char SPath[MMAX_BUFFER];
char *BPtr;
int BSpace;
char *ptr;
char *TokPtr;
char *ptr2;
char *TokPtr2;
char tEMsg[MMAX_LINE];
enum MStatusCodeEnum tmpSC;
mbool_t GRes = FALSE;
const char *FName = "MRMJobValidate";
MDB(2,fRM) MLog("%s(%s,%s,EMsg,FailureAction,SC)\n",
FName,
(J != NULL) ? J->Name : "NULL",
(R != NULL) ? R->Name : "NULL");
if (EMsg != NULL)
EMsg[0] = '\0';
if (SC != NULL)
*SC = 0;
if (J == NULL)
{
return(FAILURE);
}
if (R->ND.URL[mrmXJobValidate] == NULL)
{
/* no job validate script specified */
return(SUCCESS);
}
MUSNInit(&BPtr,&BSpace,SPath,sizeof(SPath));
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaUName],
J->Credential.U->Name);
if (J->EUser != NULL)
{
/* report execution user */
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
"EUSER",
J->EUser);
}
if (J->Credential.G != NULL)
{
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaGName],
J->Credential.G->Name);
}
if (J->SpecWCLimit[0] > 0)
{
MUSNPrintF(&BPtr,&BSpace,"%s=%ld ",
MWikiJobAttr[mwjaWCLimit],
J->SpecWCLimit[0]);
}
/*
if (J->Request.TC > 0)
{
MUSNPrintF(&BPtr,&BSpace,"%s=%d ",
MWikiJobAttr[mwjaTasks],
J->Request.TC);
}
*/
if (J->Credential.C != NULL)
{
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaRClass],
J->Credential.C->Name);
}
if (J->QOSRequested != NULL)
{
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaQOS],
J->QOSRequested->Name);
}
if (J->Env.Cmd != NULL)
{
char *ptr;
char *TokPtr;
char tmpLine[MMAX_LINE];
MUStrCpy(tmpLine,J->Env.Cmd,sizeof(tmpLine));
ptr = MUStrTok(tmpLine," ",&TokPtr);
MUStringChop(ptr);
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaExec],
ptr);
} /* END if (J->E.Cmd != NULL) */
if (!bmisclear(&J->Req[0]->ReqFBM))
{
char tmpLine[MMAX_LINE];
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaRFeatures],
MUNodeFeaturesToString(',',&J->Req[0]->ReqFBM,tmpLine));
}
if (J->Variables.Table != NULL)
{
mstring_t tmp(MMAX_LINE);
MJobAToMString(J,mjaVariables,&tmp);
MUSNPrintF(&BPtr,&BSpace,"%s=%s ",
MWikiJobAttr[mwjaVariables],
tmp.c_str());
}
/* display generic resources */
for (index = 1;index < MSched.M[mxoxGRes];index++)
{
if (MGRes.Name[index][0] == '\0')
break;
if (MSNLGetIndexCount(&J->Req[0]->DRes.GenericRes,index) == 0)
continue;
if (GRes == FALSE)
{
MUSNPrintF(&BPtr,&BSpace,"GRES=%s:%d",
MGRes.Name[index],
MSNLGetIndexCount(&J->Req[0]->DRes.GenericRes,index));
GRes = TRUE;
}
else
{
MUSNPrintF(&BPtr,&BSpace,",%s:%d",
MGRes.Name[index],
MSNLGetIndexCount(&J->Req[0]->DRes.GenericRes,index));
}
} /* END for (index) */
/* send this off to JOBVALIDATEURL */
SType = R->ND.NatType;
R->ND.NatType = mrmstX1E;
mstring_t Response(MMAX_LINE);
/* NOTE: should we pass-in Job Validate specific timeout, ie 2 seconds? (NYI) */
if (MNatDoCommand(
&R->ND,
SPath,
mrmXJobValidate,
R->ND.Protocol[mrmXJobValidate],
FALSE,
NULL,
NULL,
&Response,
tEMsg, /* O */
&tmpSC) == FAILURE)
{
R->ND.NatType = SType;
/* make failure action configurable */
if ((ptr = strstr(tEMsg,"ACTION=")) != NULL)
{
ptr += strlen("ACTION=");
ptr2 = MUStrTok(ptr," \n\t",&TokPtr);
if (FailureAction != NULL)
*FailureAction = (enum MJobCtlCmdEnum)MUGetIndexCI(ptr2,MJobCtlCmds,FALSE,mjcmNONE);
}
if (EMsg != NULL)
MUStrCpy(EMsg,tEMsg,MMAX_LINE);
if (SC != NULL)
*SC = (int)tmpSC;
return(FAILURE);
}
if (SC != NULL)
*SC = (int)tmpSC;
R->ND.NatType = SType;
for (index = 0;Response[index] != '\0';index++)
{
if (Response[index] == '\n')
Response[index] = ' ';
}
mstring_t tmpString(MMAX_LINE);
MWikiFromAVP(NULL,Response.c_str(),&tmpString);
/* Need a char array that can be modified, not the immutable tmpString */
char *mutableResponse = NULL;
MUStrDup(&mutableResponse,tmpString.c_str());
ptr = MUStrTok(mutableResponse,";",&TokPtr);
int rc = SUCCESS;
/* NYI: change other job attributes such as NodeCount RMXString User/Group */
while (ptr != NULL)
{
ptr2 = MUStrTok(ptr,"=",&TokPtr2);
aindex = (enum MWJobAttrEnum)MUGetIndexCI(ptr2,MWikiJobAttr,FALSE,mwjaNONE);
switch (aindex)
{
case mwjaAccount:
if ((J->Credential.A == NULL) || (strcmp(TokPtr2,J->Credential.A->Name)))
{
if (MRMJobModify(
J,
"Account_Name",
NULL,
TokPtr2,
mSet,
"account modified by jobvalidate interface",
tEMsg, /* O */
NULL) != SUCCESS)
{
MDB(2,fSCHED) MLog("INFO: cannot set account on job %s to '%s' - invalid account - %s\n",
J->Name,
TokPtr2,
tEMsg);
if (EMsg != NULL)
strcpy(EMsg,"cannot set account");
rc = FAILURE;
goto cleanupExit;
}
MAcctAdd(TokPtr2,&J->Credential.A);
bmset(&J->IFlags,mjifAccountLocked);
}
break;
case mwjaRClass:
if ((J->Credential.C == NULL) || (strcmp(TokPtr2,J->Credential.C->Name)))
{
mclass_t *C;
if (MClassFind(TokPtr2,&C) == FAILURE)
{
MDB(2,fSCHED) MLog("INFO: cannot set class on job %s to '%s' - invalid class\n",
J->Name,
TokPtr2);
if (EMsg != NULL)
strcpy(EMsg,"cannot locate class");
rc = FAILURE;
goto cleanupExit;
}
if (MJobSetClass(J,C,TRUE,tEMsg) == FAILURE)
{
MDB(2,fSCHED) MLog("INFO: cannot set class on job %s to '%s' - %s\n",
J->Name,
C->Name,
tEMsg);
if (EMsg != NULL)
strcpy(EMsg,"cannot set class");
rc = FAILURE;
goto cleanupExit;
}
bmset(&J->IFlags,mjifClassLocked);
} /* END if ((J->Cred.C == NULL) || ...) */
break;
case mwjaQOS:
/* bypass qos checks and put qos directly onto job */
J->QOSRequested = NULL;
if (MQOSFind(TokPtr2,&J->Credential.Q) != SUCCESS)
{
MDB(2,fSCHED) MLog("INFO: cannot set qos on job %s to '%s' - invalid QoS\n",
J->Name,
TokPtr2);
if (EMsg != NULL)
strcpy(EMsg,"cannot locate qos");
rc = FAILURE;
goto cleanupExit;
}
bmset(&J->IFlags,mjifQOSLocked);
break;
case mwjaRFeatures:
MReqSetAttr(J,J->Req[0],mrqaReqNodeFeature,(void **)TokPtr2,mdfString,mSet);
break;
case mwjaWCLimit:
if (MRMJobModify(
J,
"Resource_List",
"walltime",
TokPtr2,
mSet,
"walltime modified by jobvalidate interface",
tEMsg,
NULL) == FAILURE)
{
MDB(2,fSCHED) MLog("INFO: cannot modify walltime for rm job %s - '%s'\n",
J->Name,
tEMsg);
if (EMsg != NULL)
strcpy(EMsg,"cannot modify walltime");
rc = FAILURE;
goto cleanupExit;
}
break;
case mwjaVariables:
MJobSetAttr(J,mjaVariables,(void **)TokPtr2,mdfString,mAdd);
break;
default:
/* NO-OP */
break;
} /* END switch (aindex) */
ptr = MUStrTok(NULL,";",&TokPtr);
} /* END while (ptr != NULL) */
cleanupExit:
MUFree(&mutableResponse);
return(rc);
} /* END MRMJobValidate() */
int CPRecordLostJobs(
char *CPFile)
{
int count;
char *Buffer;
char *head;
char *ptr;
char *tokptr;
char Line[MAX_MLINE];
int buflen;
mjob_t tmpJ;
mreq_t tmpRQ;
mjob_t *J;
char tmpLine[MAX_MLINE];
char JobName[MAX_MLINE];
DBG(3,fCKPT) DPrint("CPRecordLostJobs(%s)\n",
CPFile);
/* load checkpoint file */
if ((Buffer = MFULoad(CPFile,1,macmWrite,&count,NULL)) == NULL)
{
DBG(1,fCKPT) DPrint("WARNING: cannot load checkpoint file '%s'\n",
CPFile);
return(FAILURE);
}
head = Buffer;
buflen = strlen(head);
ptr = MUStrTok(head,"\n",&tokptr);
while (ptr != NULL)
{
head = ptr + strlen(ptr) + 1;
if ((head - Buffer) > buflen)
{
head = Buffer + buflen;
}
if (!strncmp(ptr,MCPType[mcpJob],strlen(MCPType[mcpJob])))
{
/* determine job completion time estimate */
sscanf(Line,"%s %s",
tmpLine,
JobName);
if (MJobFind(JobName,&J,0) == FAILURE)
{
memset(&tmpJ,0,sizeof(tmpJ));
memset(&tmpRQ,0,sizeof(tmpRQ));
/* FIXME: only one req handled in RecordLostJobs() */
tmpJ.Req[0] = &tmpRQ;
if (MJobLoadCP(&tmpJ,ptr) == SUCCESS)
{
/* create temp record */
tmpJ.State = mjsLost;
MJobWriteStats(&tmpJ);
}
}
} /* END if (!strcmp(ptr,MCPType[])) */
} /* END while (ptr != NULL) */
return(SUCCESS);
} /* END CPRecordLostJobs() */
int UIProcessCommand(
msocket_t *S) /* I */
{
char SBuffer[MAX_SBUFFER];
char Message[MAX_MLINE];
int HeadSize;
int index;
int sindex;
int FLAGS;
int hostcheck;
char ServiceType[MAX_MLINE];
char Auth[MAX_MNAME];
char Passwd[MAX_MNAME];
int scode;
int Align;
char *ptr;
char *ptr2;
char *args;
char *TokPtr;
int rc;
long tmpL;
char tmpLine[MMAX_LINE];
const char *FName = "UIProcessCommand";
DBG(3,fUI) DPrint("%s(S)\n",
FName);
if (S == NULL)
{
return(FAILURE);
}
if (MSURecvData(S,MAX_SOCKETWAIT,TRUE,NULL,NULL) == FAILURE)
{
DBG(3,fSOCK) DPrint("ALERT: cannot read client packet\n");
return(FAILURE);
}
switch(S->WireProtocol)
{
case mwpXML:
rc = MUISProcessRequest(S,Message);
return(rc);
/*NOTREACHED*/
break;
default:
break;
} /* END switch(S->WireProtocol) */
memset(SBuffer,0,sizeof(SBuffer));
S->SBuffer = SBuffer;
strcpy(CurrentHostName,S->Host); /* NOTE: not very threadsafe :) */
if ((X.XUIHandler != (int (*)())0) &&
((*X.XUIHandler)(X.xd,S,MSched.DefaultCSKey,0) == SUCCESS))
{
/* service handled externally */
return(SUCCESS);
}
if (MUISProcessRequest(S,Message) == SUCCESS)
{
/* new style client request received and processed */
return(SUCCESS);
}
/* locate/process args */
if ((args = strstr(S->RBuffer,MCKeyword[mckArgs])) == NULL)
{
DBG(3,fSOCK) DPrint("ALERT: cannot locate command arg\n");
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
"ERROR: cannot locate command args");
S->SBufSize = strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
}
*args = '\0';
args += strlen(MCKeyword[mckArgs]);
/* get service */
ServiceType[0] = '\0';
if ((ptr = strstr(S->RBuffer,MCKeyword[mckCommand])) == NULL)
{
DBG(3,fSOCK) DPrint("ALERT: cannot locate command\n");
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
"ERROR: cannot locate command");
S->SBufSize = strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
}
ptr += strlen(MCKeyword[mckCommand]);
MUStrCpy(ServiceType,ptr,sizeof(ServiceType));
for (ptr2 = &ServiceType[0];*ptr2 != '\0';ptr2++)
{
if (isspace(*ptr2))
{
*ptr2 = '\0';
break;
}
} /* END for (ptr2) */
/* get authentication */
if ((ptr = strstr(S->RBuffer,MCKeyword[mckAuth])) == NULL)
{
DBG(3,fSOCK) DPrint("ALERT: cannot locate authentication\n");
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
"ERROR: cannot locate authentication");
S->SBufSize = (long)strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
}
ptr += strlen(MCKeyword[mckAuth]);
MUStrCpy(Auth,ptr,sizeof(Auth));
/* FORMAT: <USERNAME>[:<PASSWORD>] */
for (ptr2 = &Auth[0];*ptr2 != '\0';ptr2++)
{
if (isspace(*ptr2))
{
*ptr2 = '\0';
break;
}
}
if ((ptr2 = MUStrTok(Auth,":",&TokPtr)) != NULL)
{
MUStrCpy(Passwd,ptr2,sizeof(Passwd));
}
else
{
Passwd[0] = '\0';
}
/* determine service */
if ((sindex = MUGetIndex(ServiceType,MService,0,0)) == 0)
{
DBG(3,fUI) DPrint("INFO: service '%s' not handled in %s\n",
ServiceType,
FName);
sprintf(Message,"ERROR: cannot support service '%s'",
ServiceType);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
}
DBG(3,fUI) DPrint("INFO: client '%s' read (%ld bytes) initiating service call for '%s' (Auth: %s)\n",
S->Name,
S->SBufSize,
MService[sindex],
Auth);
/* fail if name is not recognized */
if (Auth[0] == '\0')
{
DBG(2,fUI) DPrint("WARNING: client id '%s' is unknown\n",
Auth);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
"ERROR: cannot authenticate client");
S->SBufSize = (long)strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
}
ServerGetAuth(Auth,&tmpL);
FLAGS = (int)tmpL;
switch(sindex)
{
/* admin1 functions */
case svcResetStats:
case svcSched:
case svcSetJobDeadline:
case svcReleaseJobDeadline:
case svcChangeParameter:
case svcMigrateJob:
case svcBNFQuery:
case svcMGridCtl:
case svcMJobCtl:
case svcMNodeCtl:
if (!(FLAGS & (1 << fAdmin1)))
{
sprintf(Message,"ERROR: user '%s' is not authorized to run command '%s'\n",
Auth,
MService[sindex]);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
/*NOTREACHED*/
break;
}
hostcheck = FALSE;
for (index = 0;index < MAX_MADMINHOSTS;index++)
{
if (MSched.AdminHost[index][0] == '\0')
break;
if (!strcasecmp(MSched.AdminHost[index],S->Host))
{
hostcheck = TRUE;
break;
}
if (!strcasecmp(MSched.AdminHost[index],"ALL"))
{
hostcheck = TRUE;
break;
}
} /* END for (index) */
if (hostcheck == FALSE)
{
sprintf(Message,"ERROR: command '%s' cannot be executed from host '%s'\n",
MService[sindex],
S->Host);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
/*NOTREACHED*/
break;
}
/* admin1 or admin2 function */
case svcSetJobSystemPrio:
case svcRunJob:
if (!(FLAGS & ((1 << fAdmin1) | (1 << fAdmin2))))
{
sprintf(Message,"ERROR: user '%s' is not authorized to execute command '%s'\n",
Auth,
MService[sindex]);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
/*NOTREACHED*/
break;
}
/* admin1, admin2, or admin3 functions */
case svcShowStats:
case svcDiagnose:
case svcShowJobDeadline:
case svcShowConfig:
case svcNodeShow:
case svcShowEstimatedStartTime:
case svcShowGrid:
case svcClusterShow:
if (!(FLAGS & ((1 << fAdmin1) | (1 << fAdmin2) | (1 << fAdmin3))))
{
sprintf(Message,"ERROR: user '%s' is not authorized to execute command '%s'\n",
Auth,
MService[sindex]);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
return(FAILURE);
/*NOTREACHED*/
break;
}
/* global functions or case specific functions */
case svcResCreate:
case svcResShow:
case svcSetJobQOS:
case svcCancelJob:
case svcSetJobUserPrio:
case svcJobShow:
case svcShowQ:
case svcSetJobHold:
case svcReleaseJobHold:
case svcResDestroy:
case svcShowJobHold:
case svcShowEarliestDeadline:
case svcShowBackfillWindow:
case svcMBal:
if (sindex == svcMGridCtl)
strcpy(Auth,S->Name);
S->SBufSize = (long)sizeof(SBuffer);
sprintf(tmpLine,"%s%d ",
MCKeyword[mckStatusCode],
scFAILURE);
Align = (int)strlen(tmpLine) + (int)strlen(MCKeyword[mckArgs]);
sprintf(S->SBuffer,"%s%*s%s",
tmpLine,
16 - (Align % 16),
" ",
MCKeyword[mckArgs]);
HeadSize = (int)strlen(SBuffer);
S->SBufSize -= HeadSize + 1;
if (Function[sindex] != NULL)
scode = (*Function[sindex])(args,S->SBuffer + HeadSize,FLAGS,Auth,&S->SBufSize);
else
scode = FAILURE;
ptr = S->SBuffer + strlen(MCKeyword[mckStatusCode]);
*ptr = scode + '0';
S->SBufSize = (long)strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
break;
default:
DBG(2,fUI) DPrint("WARNING: unexpected service (%d) requested (ignoring request)\n",
sindex);
sprintf(Message,"ERROR: service '%s' (%d) not implemented\n",
ServiceType,
sindex);
sprintf(S->SBuffer,"%s%d %s%s\n",
MCKeyword[mckStatusCode],
scFAILURE,
MCKeyword[mckArgs],
Message);
S->SBufSize = (long)strlen(S->SBuffer);
MSUSendData(S,MAX_SOCKETWAIT,TRUE,TRUE);
break;
} /* END switch(sindex) */
fflush(mlog.logfp);
return(SUCCESS);
} /* END UIProcessCommand() */
int MCPLoad(
char *CPFile, /* I (utilized) */
int Mode) /* I */
{
char *ptr;
char *head;
int ckindex;
int count;
int buflen;
char *tokptr;
static int FailureIteration = -999;
const char *FName = "MCPLoad";
DBG(3,fCKPT) DPrint("%s(%s,%s)\n",
FName,
CPFile,
(Mode == mckptResOnly) ? "ResOnly" : "NonRes");
if ((MSched.Mode == msmSim) &&
(getenv(MSCHED_ENVCKTESTVAR) == NULL))
{
/* checkpointing not enabled */
return(SUCCESS);
}
if (FailureIteration == MSched.Iteration)
{
return(FAILURE);
}
/* load checkpoint file */
if ((MCP.OBuffer = MFULoad(CPFile,1,macmWrite,&count,NULL)) == NULL)
{
DBG(1,fCKPT) DPrint("WARNING: cannot load checkpoint file '%s'\n",
CPFile);
FailureIteration = MSched.Iteration;
return(FAILURE);
}
head = MCP.OBuffer;
buflen = strlen(head);
/* determine checkpoint version */
if (MCP.DVersion[0] == '\0')
{
MCPRestore(mcpSched,"sched",(void *)&MSched);
if (MCPIsSupported(&MCP,MCP.DVersion) == FALSE)
{
/* cannot load checkpoint file */
return(FAILURE);
}
}
ptr = MUStrTok(head,"\n",&tokptr);
while (ptr != NULL)
{
head = ptr + strlen(ptr) + 1;
if ((head - MCP.OBuffer) > buflen)
{
head = MCP.OBuffer + buflen;
}
for (ckindex = 0;MCPType[ckindex] != NULL;ckindex++)
{
if (strncmp(ptr,MCPType[ckindex],strlen(MCPType[ckindex])))
continue;
if ((Mode == mckptResOnly) &&
(ckindex != mcpRes) &&
(ckindex != mcpSRes) &&
(ckindex != mcpSched))
{
break;
}
else if ((Mode == mckptNonRes) &&
(ckindex == mcpRes))
{
break;
}
DBG(5,fCKPT) DPrint("INFO: loading %s checkpoint data '%s'\n",
MCPType[ckindex],
ptr);
switch(ckindex)
{
case mcpSched:
if (MCPLoadSched(&MCP,ptr,&MSched) == FAILURE)
{
DBG(1,fCKPT) DPrint("ALERT: cannot load sched data. aborting checkpoint load\n");
free(MCP.OBuffer);
MCP.OBuffer = NULL;
return(FAILURE);
}
break;
case mcpSys:
MCPLoadSys(&MCP,ptr,&MSched);
break;
case mcpJob:
MJobLoadCP(NULL,ptr);
break;
case mcpRes:
MResLoadCP(NULL,ptr);
break;
case mcpSRes:
MCPLoadSR(ptr);
break;
case mcpNode:
MNodeLoadCP(NULL,ptr);
break;
case mcpUser:
MUserLoadCP(NULL,ptr);
break;
case mcpGroup:
MGroupLoadCP(NULL,ptr);
break;
case mcpAcct:
MAcctLoadCP(NULL,ptr);
break;
case mcpTotal:
case mcpRTotal:
case mcpCTotal:
case mcpGTotal:
MCPLoadStats(ptr);
break;
case mcpSysStats:
MCPLoadSysStats(ptr);
break;
default:
DBG(1,fCKPT) DPrint("ERROR: line '%s' not handled in checkPoint file '%s'\n",
ptr,
CPFile);
break;
} /* END switch(ckindex) */
break;
} /* END for (ckindex) */
if (MCPType[ckindex] == NULL)
{
DBG(3,fCKPT) DPrint("WARNING: unexpected line '%s' in checkpoint file '%s'\n",
ptr,
CPFile);
}
ptr = MUStrTok(NULL,"\n",&tokptr);
} /* END while (ptr != NULL) */
free(MCP.OBuffer);
MCP.OBuffer = NULL;
if (Mode == mckptNonRes)
{
MSysSynchronize();
}
return(SUCCESS);
} /* END MCPLoad() */
int MTraceLoadWorkload(
char *Buffer, /* I */
int *TraceLen, /* I (optional,modified) */
mjob_t *J, /* O */
int Mode, /* I */
int *Version) /* O */
{
char *tail;
char *head;
char *ptr;
char *ptr2;
char *tok;
char *TokPtr;
char Line[MAX_MLINE << 4];
char tmpLine[MAX_MLINE];
char MHostName[MAX_MNAME];
char MReqHList[MAX_MLINE << 2];
char Reservation[MAX_MNAME];
char tmpTaskRequest[MAX_MLINE];
char tmpSpecWCLimit[MAX_MLINE];
char tmpState[MAX_WORD];
char tmpOpsys[MAX_WORD];
char tmpArch[MAX_WORD];
char tmpNetwork[MAX_WORD];
char tmpMemCmp[MAX_WORD];
char tmpDiskCmp[MAX_WORD];
char tmpReqNFList[MAX_MLINE];
char tmpClass[MAX_MLINE];
char tmpRMName[MAX_MLINE];
char tmpCmd[MAX_MLINE];
char tmpRMXString[MAX_MLINE >> 2];
char tmpParName[MAX_MNAME];
char tmpJFlags[MAX_MLINE];
char tmpQReq[MAX_WORD];
char tmpASString[MAX_MLINE];
char tmpRMemBuf[MAX_MNAME];
char tmpRDiskBuf[MAX_MNAME];
char tmpDSwapBuf[MAX_MNAME];
char tmpDMemBuf[MAX_MNAME];
char tmpDDiskBuf[MAX_MNAME];
char UName[MAX_MNAME];
char GName[MAX_MNAME];
char AName[MAX_MNAME];
char SetString[MAX_MLINE];
unsigned long tmpQTime;
unsigned long tmpDTime;
unsigned long tmpSTime;
unsigned long tmpCTime;
unsigned long tmpSQTime;
unsigned long tmpSDate;
unsigned long tmpEDate;
int TPN;
int TasksAllocated;
int index;
int rc;
int tindex;
int nindex;
mqos_t *QDef;
mreq_t *RQ[MAX_MREQ_PER_JOB];
mnode_t *N;
long ReqProcSpeed;
const char *FName = "MTraceLoadWorkload";
DBG(5,fSIM) DPrint("%s(Buffer,TraceLen,J,%d,%d)\n",
FName,
Mode,
(Version != NULL) ? *Version : -1);
if (J == NULL)
{
DBG(5,fSIM) DPrint("ALERT: NULL job pointer passed in %s()\n",
FName);
return(FAILURE);
}
if (Buffer == NULL)
{
return(FAILURE);
}
if ((tail = strchr(Buffer,'\n')) == NULL)
{
/* assume line is '\0' terminated */
if (TraceLen != NULL)
tail = Buffer + *TraceLen;
else
tail = Buffer + strlen(Buffer);
}
head = Buffer;
MUStrCpy(Line,head,MIN(tail - head + 1,sizeof(Line)));
DBG(6,fSIM) DPrint("INFO: parsing trace line '%s'\n",
Line);
if (TraceLen != NULL)
*TraceLen = (tail - head) + 1;
/* eliminate comments */
if ((ptr = strchr(Line,'#')) != NULL)
{
DBG(5,fSIM) DPrint("INFO: detected trace comment line, '%s'\n",
Line);
*ptr = '\0';
}
if (Line[0] == '\0')
{
return(FAILURE);
}
/* look for VERSION settings */
if (!strncmp(Line,TRACE_WORKLOAD_VERSION_MARKER,strlen(TRACE_WORKLOAD_VERSION_MARKER)))
{
if (MTraceGetWorkloadVersion(Line,Version) == FAILURE)
{
DBG(0,fSIM) DPrint("ALERT: cannot determine workload trace version\n");
/* assume default version */
if (Version != NULL)
*Version = DEFAULT_WORKLOAD_TRACE_VERSION;
}
else
{
DBG(3,fSIM) DPrint("INFO: workload trace version %d detected\n",
(Version != NULL) ? *Version : -1);
}
return(FAILURE);
} /* END if (!strncmp(Line,TRACE_WORKLOAD_VERSION_MARKER)) */
/* set default workload attributes */
memset(J,0,sizeof(mjob_t));
if (MReqCreate(J,NULL,&J->Req[0],FALSE) == FAILURE)
{
DBG(0,fSIM) DPrint("ALERT: cannot create job req\n");
return(FAILURE);
}
MRMJobPreLoad(J,NULL,0);
RQ[0] = J->Req[0];
RQ[0]->Index = 0;
J->StartCount = 0;
J->R = NULL;
switch(*Version)
{
case 230:
/* Name NR TReq User Grop WClk Stat Clss QUT DST STT CMT netw Arch Opsy MemC RMem DskC RDsk Feat SQT TA TPN QO MO AC CM CC BP PU Part DPrc DMem DDisk DSwap STARTDATE ENDDATE MNODE RM HL RES RES1 RES2 RES3 OVERFLOW */
rc = sscanf(Line,"%64s %d %64s %64s %64s %64s %64s %64s %lu %lu %lu %lu %64s %64s %64s %64s %64s %64s %64s %64s %lu %d %d %64s %1024s %64s %1024s %1024s %d %lf %64s %d %64s %64s %64s %lu %lu %1024s %64s %1024s %64s %64s %1024s %s %s",
J->Name,
&J->Request.NC,
tmpTaskRequest,
UName,
GName,
tmpSpecWCLimit,
tmpState,
tmpClass,
&tmpQTime,
&tmpDTime,
&tmpSTime,
&tmpCTime,
tmpNetwork,
tmpArch,
tmpOpsys,
tmpMemCmp,
tmpRMemBuf,
tmpDiskCmp,
tmpRDiskBuf,
tmpReqNFList,
&tmpSQTime, /* SystemQueueTime */
&TasksAllocated, /* allocated task count */
&TPN,
tmpQReq,
tmpJFlags,
AName,
tmpCmd,
tmpRMXString, /* RM extension string */
&J->Bypass, /* Bypass */
&J->PSUtilized, /* PSUtilized */
tmpParName, /* partition used */
&RQ[0]->DRes.Procs,
tmpDMemBuf,
tmpDDiskBuf,
tmpDSwapBuf,
&tmpSDate,
&tmpEDate,
MHostName,
tmpRMName,
MReqHList,
Reservation,
SetString, /* resource sets required by job */
tmpASString, /* application simulator name */
tmpLine, /* RES1 */
tmpLine /* check for too many fields */
);
/* fail if all fields not read in */
switch (rc)
{
case 43:
strcpy(MHostName,NONE);
J->RM = &MRM[0];
break;
case 44:
/* canonical 230 trace */
if (isdigit(tmpRMName[0]))
J->RM = &MRM[(int)strtol(tmpRMName,NULL,0)];
else
J->RM = &MRM[0];
break;
default:
DBG(1,fSIM) DPrint("ALERT: version %d workload trace is corrupt '%s' (%d of %d fields read) ignoring line\n",
*Version,
Line,
rc,
44);
MJobDestroy(&J);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch(rc) */
RQ[0]->RequiredMemory = MURSpecToL(tmpRMemBuf,mvmMega,mvmMega);
RQ[0]->RequiredDisk = MURSpecToL(tmpRDiskBuf,mvmMega,mvmMega);
RQ[0]->DRes.Mem = MURSpecToL(tmpDMemBuf,mvmMega,mvmMega);
RQ[0]->DRes.Swap = MURSpecToL(tmpDSwapBuf,mvmMega,mvmMega);
RQ[0]->DRes.Disk = MURSpecToL(tmpDDiskBuf,mvmMega,mvmMega);
if (Mode != msmProfile)
{
ptr = NULL;
ptr2 = NULL;
if (strcmp(tmpASString,NONE))
{
if ((ptr = MUStrTok(tmpASString,":",&TokPtr)) != NULL)
{
ptr2 = MUStrTok(NULL,"|",&TokPtr);
}
}
if (MASGetDriver((void **)&J->ASFunc,ptr,msdApplication) == SUCCESS)
{
(*J->ASFunc)(J,mascCreate,ptr2,NULL);
}
} /* END if (Mode != msmProfile) */
/* obtain job step number from LL based job name */
/* FORMAT: <FROM_HOST>.<CLUSTER>.<PROC> */
MUStrCpy(tmpLine,J->Name,sizeof(tmpLine));
if ((ptr = MUStrTok(tmpLine,".",&TokPtr)) != NULL)
{
MUStrCpy(J->SubmitHost,ptr,sizeof(J->SubmitHost));
if ((ptr = MUStrTok(NULL,".",&TokPtr)) != NULL)
{
J->Cluster = (int)strtol(ptr,NULL,0);
if ((ptr = MUStrTok(NULL,".",&TokPtr)) != NULL)
{
J->Proc = (int)strtol(ptr,NULL,0);
}
}
}
/* adjust job flags */
if (Mode == msmProfile)
{
MUStrDup(&J->MasterHostName,MHostName);
/* NOTE: flags may be specified as string or number */
if ((J->SpecFlags = strtol(tmpJFlags,NULL,0)) == 0)
{
MUBMFromString(tmpJFlags,MJobFlags,&J->SpecFlags);
}
}
else
{
/* simulation mode */
if ((MSim.Flags & (1 << msimfIgnMode)) ||
(MSim.Flags & (1 << msimfIgnAll)))
{
J->SpecFlags = 0;
}
else
{
/* NOTE: flags may be specified as string or number */
if ((J->SpecFlags = strtol(tmpJFlags,NULL,0)) == 0)
{
MUBMFromString(tmpJFlags,MJobFlags,&J->SpecFlags);
}
if (J->SysFlags & (1 << mjfBackfill))
J->SysFlags ^= (1 << mjfBackfill);
if ((J->SpecFlags & (1 << mjfHostList)) &&
(MSim.Flags & (1 << msimfIgnHostList)))
{
J->SpecFlags ^= (1 << mjfHostList);
}
}
} /* END else (Mode == msmProfile) */
/* extract arbitrary job attributes */
/* FORMAT: JATTR:<ATTR>[=<VALUE>] */
{
char *ptr;
char *TokPtr;
ptr = MUStrTok(tmpJFlags,"[]",&TokPtr);
while (ptr != NULL)
{
if (!strncmp(ptr,"JATTR:",strlen("JATTR:")))
{
MJobSetAttr(J,mjaGAttr,(void **)(ptr + strlen("JATTR:")),0,mSet);
}
ptr = MUStrTok(NULL,"[]",&TokPtr);
} /* END while (ptr != NULL) */
} /* END BLOCK */
/* set default flags, remove set 'ignore' flags */
J->SpecFlags |= MSim.TraceDefaultJobFlags;
for (index = 0;index < M64.INTBITS;index++)
{
if (!(MSim.TraceIgnoreJobFlags & (1 << index)))
continue;
if (!(J->SpecFlags & (1 << index)))
continue;
J->SpecFlags ^= (1 << index);
} /* END for (index) */
/* load task info */
if (!strncmp(tmpTaskRequest,"PBS=",strlen("PBS=")))
{
char tmpLine[MAX_MLINE];
tpbsa_t tmpA;
short TaskList[MAX_MTASK];
memset(&tmpA,0,sizeof(tmpA));
sprintf(tmpLine,"Resource_List,nodes,%s",
&tmpTaskRequest[strlen("PBS=")]);
MPBSJobSetAttr(J,NULL,tmpLine,&tmpA,TaskList,0);
MPBSJobAdjustResources(J,&tmpA,J->RM);
}
else
{
ptr = MUStrTok(tmpTaskRequest,",",&TokPtr);
tindex = 1;
while (ptr != NULL)
{
if (strchr(ptr,'-') != NULL)
{
/* NOTE: not handled */
}
else
{
RQ[0]->TaskRequestList[tindex] = atoi(ptr);
tindex++;
}
ptr = MUStrTok(NULL,",",&TokPtr);
}
RQ[0]->TaskRequestList[tindex] = 0;
RQ[0]->TaskRequestList[0] = RQ[0]->TaskRequestList[1];
RQ[0]->TaskCount = RQ[0]->TaskRequestList[0];
J->Request.TC = RQ[0]->TaskRequestList[0];
RQ[0]->TasksPerNode = MAX(0,TPN);
if (MPar[0].JobNodeMatch & (1 << nmExactNodeMatch))
{
RQ[0]->NodeCount = RQ[0]->TaskCount;
J->Request.NC = RQ[0]->TaskCount;
}
if (MPar[0].JobNodeMatch & (1 << nmExactProcMatch))
{
if (RQ[0]->TasksPerNode >= 1)
{
RQ[0]->RequiredProcs = RQ[0]->TasksPerNode;
RQ[0]->ProcCmp = mcmpEQ;
}
if (RQ[0]->TasksPerNode > J->Request.TC)
{
RQ[0]->TasksPerNode = 0;
}
}
} /* END BLOCK */
/* process WCLimit constraints */
ptr = MUStrTok(tmpSpecWCLimit,",:",&TokPtr);
tindex = 1;
while (ptr != NULL)
{
if (strchr(ptr,'-') != NULL)
{
/* NOTE: not handled */
}
else
{
J->SpecWCLimit[tindex] = strtol(ptr,NULL,0);
tindex++;
}
ptr = MUStrTok(NULL,",:",&TokPtr);
} /* END while (ptr != NULL) */
J->SpecWCLimit[tindex] = 0;
J->SpecWCLimit[0] = J->SpecWCLimit[1];
J->SubmitTime = tmpQTime;
J->DispatchTime = MAX(tmpDTime,tmpSTime);
J->StartTime = MAX(tmpDTime,tmpSTime);
J->CompletionTime = tmpCTime;
J->SystemQueueTime = tmpSQTime;
J->SpecSMinTime = tmpSDate;
J->CMaxTime = tmpEDate;
/* determine required reservation */
if (strcmp(Reservation,NONE) &&
strcmp(Reservation,J->Name))
{
J->SpecFlags |= (1 << mjfAdvReservation);
if (strcmp(Reservation,ALL) != 0)
{
strcpy(J->ResName,Reservation);
}
}
/* determine job class */
if ((MSim.Flags & (1 << msimfIgnClass)) ||
(MSim.Flags & (1 << msimfIgnAll)))
{
mclass_t *C;
MClassAdd("DEFAULT",&C);
/* ignore specified classes */
RQ[0]->DRes.PSlot[0].count = 1;
RQ[0]->DRes.PSlot[C->Index].count = 1;
}
else
{
int cindex;
MUNumListFromString(RQ[0]->DRes.PSlot,tmpClass,eClass);
for (cindex = 1;cindex < MAX_MCLASS;cindex++)
{
if (RQ[0]->DRes.PSlot[cindex].count > 0)
{
MClassAdd(MAList[eClass][cindex],NULL);
}
} /* END for (cindex) */
}
if (Mode != msmProfile)
{
if ((strcmp(MReqHList,NONE) != 0) &&
!(MSim.Flags & (1 << msimfIgnHostList)) &&
!(MSim.Flags & (1 << msimfIgnAll)))
{
J->SpecFlags |= (1 << mjfHostList);
ptr = MUStrTok(MReqHList,":",&TokPtr);
nindex = 0;
if (J->ReqHList == NULL)
J->ReqHList = (mnalloc_t *)calloc(1,sizeof(mnalloc_t) * (MAX_MNODE_PER_JOB + 1));
J->ReqHList[0].N = NULL;
while (ptr != NULL)
{
if (MNodeFind(ptr,&N) == FAILURE)
{
if (MSched.DefaultDomain[0] != '\0')
{
if ((tail = strchr(ptr,'.')) != NULL)
{
/* try short name */
MUStrCpy(MReqHList,ptr,MIN(sizeof(MReqHList),(tail - ptr + 1)));
}
else
{
/* append default domain */
if (MSched.DefaultDomain[0] == '.')
{
sprintf(MReqHList,"%s%s",
ptr,
MSched.DefaultDomain);
}
else
{
sprintf(MReqHList,"%s.%s",
ptr,
MSched.DefaultDomain);
}
}
if (MNodeFind(MReqHList,&N) != SUCCESS)
{
DBG(1,fUI) DPrint("ALERT: cannot locate node '%s' for job '%s' hostlist\n",
ptr,
J->Name);
N = NULL;
}
}
else
{
DBG(1,fUI) DPrint("ALERT: cannot locate node '%s' for job '%s' hostlist\n",
ptr,
J->Name);
N = NULL;
}
} /* END if (MNodeFind() == FAILURE) */
if (N != NULL)
{
if (J->ReqHList[nindex].N == N)
{
J->ReqHList[nindex].TC++;
}
else
{
if (J->ReqHList[nindex].N != NULL)
nindex++;
J->ReqHList[nindex].N = N;
J->ReqHList[nindex].TC = 1;
}
}
ptr = MUStrTok(NULL,":",&TokPtr);
} /* END while (ptr != NULL) */
J->ReqHList[nindex + 1].N = NULL;
} /* END if (strcmp(MReqHList,NONE)) */
else if ((J->SpecFlags & (1 << mjfHostList)) &&
(J->ReqHList == NULL))
{
DBG(1,fSIM) DPrint("ALERT: job %s requests hostlist but has no hostlist specified\n",
J->Name);
J->SpecFlags ^= (1 << mjfHostList);
}
} /* END if (MODE != msmProfile) */
break;
default:
DBG(4,fSIM) DPrint("ALERT: cannot load version %d workload trace record\n",
*Version);
MJobDestroy(&J);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch(*Version) */
if (!strcmp(AName,NONE) ||
!strcmp(AName,"0"))
{
AName[0] = '\0';
}
if ((strcmp(tmpRMXString,NONE) != 0) && (strcmp(tmpRMXString,"0") != 0))
{
MJobSetAttr(J,mjaRMXString,(void **)tmpRMXString,mdfString,0);
}
if (RQ[0]->DRes.Procs == 0)
RQ[0]->DRes.Procs = 1;
if (J->SpecWCLimit[0] == (unsigned long)-1)
J->SpecWCLimit[0] = MAX_MTIME;
MUStrDup(&J->E.Cmd,tmpCmd);
if (Mode == msmSim)
{
J->State = mjsIdle;
J->EState = mjsIdle;
J->Bypass = 0;
J->PSUtilized = 0.0;
J->SystemQueueTime = J->SubmitTime;
J->SimWCTime = MAX(1,J->CompletionTime - J->StartTime);
J->StartTime = 0;
J->DispatchTime = 0;
J->CompletionTime = 0;
J->WCLimit = J->SpecWCLimit[0];
}
else
{
/* profile mode */
int tmpI;
tmpI = (int)strtol(tmpParName,NULL,0);
if (tmpI > 0)
{
RQ[0]->PtIndex = tmpI;
}
else
{
mpar_t *P;
MParFind(tmpParName,&P);
RQ[0]->PtIndex = P->Index;
}
J->TaskCount = TasksAllocated;
J->PSDedicated = MJobGetProcCount(J) * (J->CompletionTime - J->StartTime);
J->WCLimit = J->SpecWCLimit[0];
for (index = 0;MJobState[index] != NULL;index++)
{
if (!strcmp(tmpState,MJobState[index]))
{
J->State = index;
J->EState = index;
break;
}
} /* END for (index) */
}
if (J->State == mjsNotRun)
{
DBG(3,fSIM) DPrint("ALERT: ignoring job '%s' (job never ran, state '%s')\n",
J->Name,
MJobState[J->State]);
MJobDestroy(&J);
return(FAILURE);
}
/* check for timestamp corruption */
if (Mode == msmProfile)
{
/* profiler mode */
if (MSched.TraceFlags & (1 << tfFixCorruption))
{
if (J->StartTime < J->DispatchTime)
{
DBG(2,fSIM) DPrint("WARNING: fixing job '%s' with corrupt dispatch/start times (%ld < %ld)\n",
J->Name,
J->DispatchTime,
J->StartTime);
J->DispatchTime = J->StartTime;
}
if (J->SubmitTime > J->StartTime)
{
DBG(2,fSIM) DPrint("WARNING: fixing job '%s' with corrupt queue/start times (%ld > %ld)\n",
J->Name,
J->SubmitTime,
J->StartTime);
if (J->SystemQueueTime > 0)
J->SubmitTime = MIN(J->StartTime,J->SystemQueueTime);
else
J->SubmitTime = J->StartTime;
}
if (J->SystemQueueTime > J->DispatchTime)
{
DBG(2,fSIM) DPrint("WARNING: fixing job '%s' with corrupt system queue/dispatch times (%ld > %ld)\n",
J->Name,
J->SystemQueueTime,
J->DispatchTime);
J->SystemQueueTime = J->DispatchTime;
}
if (J->SystemQueueTime < J->SubmitTime)
{
DBG(2,fSIM) DPrint("WARNING: fixing job '%s' with corrupt system queue/queue time (%ld < %ld)\n",
J->Name,
J->SystemQueueTime,
J->SubmitTime);
J->SystemQueueTime = J->SubmitTime;
}
} /* END if (MSched.TraceFlags & (1 << tfFixCorruption)) */
if ((J->SubmitTime > J->DispatchTime) ||
(J->DispatchTime > J->CompletionTime))
{
DBG(1,fSIM) DPrint("ALERT: ignoring job '%s' with corrupt queue/start/completion times (%ld > %ld > %ld)\n",
J->Name,
J->SubmitTime,
J->DispatchTime,
J->CompletionTime);
MJobDestroy(&J);
return(FAILURE);
}
} /* END if (Mode != msmSim) */
if (MJobSetCreds(J,UName,GName,AName) == FAILURE)
{
DBG(1,fSTRUCT) DPrint("ALERT: ignoring job '%s' with invalid authentication info (%s:%s:%s)\n",
J->Name,
UName,
GName,
AName);
MJobDestroy(&J);
return(FAILURE);
}
/* determine network */
if (strstr(tmpNetwork,MAList[eNetwork][0]) == NULL)
{
RQ[0]->Network = MUMAGetIndex(eNetwork,tmpNetwork,mAdd);
}
if (strstr(tmpOpsys,MAList[eOpsys][0]) == NULL)
{
if ((RQ[0]->Opsys = MUMAGetIndex(eOpsys,tmpOpsys,mAdd)) == FAILURE)
{
DBG(0,fSIM) DPrint("WARNING: cannot add opsys '%s' for job '%s'\n",
tmpOpsys,
J->Name);
}
}
if (strstr(tmpArch,MAList[eArch][0]) == NULL)
{
if ((RQ[0]->Arch = MUMAGetIndex(eArch,tmpArch,mAdd)) == FAILURE)
{
DBG(0,fSIM) DPrint("WARNING: cannot add arch '%s' for job '%s'\n",
tmpArch,
J->Name);
}
}
/* load feature values */
if ((MSched.ProcSpeedFeatureHeader[0] != '\0') &&
(MSched.ReferenceProcSpeed > 0))
{
sprintf(tmpLine,"[%s",
MSched.ProcSpeedFeatureHeader);
if ((ptr = strstr(tmpReqNFList,tmpLine)) != NULL)
{
ReqProcSpeed = strtol(ptr + strlen(tmpLine),NULL,0);
J->SimWCTime *= (long)((double)ReqProcSpeed / MSched.ReferenceProcSpeed);
}
}
if ((MSched.Mode != msmSim) || !(MSim.Flags & (1 << msimfIgnFeatures)))
{
if (!strstr(tmpReqNFList,MAList[eFeature][0]))
{
tok = MUStrTok(tmpReqNFList,"[]",&TokPtr);
do
{
MUGetMAttr(eFeature,tok,mAdd,RQ[0]->ReqFBM,sizeof(RQ[0]->ReqFBM));
}
while ((tok = MUStrTok(NULL,"[]",&TokPtr)) != NULL);
}
}
RQ[0]->MemCmp = MUCmpFromString(tmpMemCmp,NULL);
RQ[0]->DiskCmp = MUCmpFromString(tmpDiskCmp,NULL);
RQ[0]->NAccessPolicy = MSched.DefaultNAccessPolicy;
RQ[0]->TaskCount = J->Request.TC;
RQ[0]->NodeCount = J->Request.NC;
MJobProcessExtensionString(J,J->RMXString);
if ((MSim.Flags & (1 << msimfIgnQOS)))
{
tmpQReq[0] = '\0';
}
{
char *ptr;
char *TokPtr;
ptr = MUStrTok(tmpQReq,":",&TokPtr);
if ((ptr != NULL) &&
(ptr[0] != '\0') &&
strcmp(ptr,"-1") &&
strcmp(ptr,"0") &&
strcmp(ptr,NONE) &&
strcmp(ptr,DEFAULT))
{
if (MQOSAdd(ptr,&J->QReq) == FAILURE)
{
/* cannot locate requested QOS */
MQOSFind(DEFAULT,&J->QReq);
}
if (Mode == msmProfile)
{
if ((ptr = MUStrTok(NULL,":",&TokPtr)) != NULL)
{
MQOSAdd(ptr,&J->Cred.Q);
}
}
} /* END if ((ptr != NULL) && ...) */
} /* END BLOCK */
if (Mode == msmSim)
{
if ((MQOSGetAccess(J,J->QReq,NULL,&QDef) == FAILURE) ||
(J->QReq == NULL) ||
(J->QReq == &MQOS[0]))
{
MJobSetQOS(J,QDef,0);
}
else
{
MJobSetQOS(J,J->QReq,0);
}
} /* END if (Mode == msmSim) */
if ((SetString[0] != '0') && (strcmp(SetString,NONE)))
{
/* FORMAT: ONEOF,FEATURE[,X:Y:Z] */
if ((ptr = MUStrTok(SetString,",: \t",&TokPtr)) != NULL)
{
/* determine selection type */
RQ[0]->SetSelection = MUGetIndex(ptr,(const char **)MResSetSelectionType,0,mrssNONE);
if ((ptr = MUStrTok(NULL,",: \t",&TokPtr)) != NULL)
{
/* determine set attribute */
RQ[0]->SetType = MUGetIndex(ptr,(const char **)MResSetAttrType,0,mrstNONE);
index = 0;
if ((ptr = MUStrTok(NULL,", \t",&TokPtr)) != NULL)
{
/* determine set list */
while (ptr != NULL)
{
MUStrDup(&RQ[0]->SetList[index],ptr);
index++;
ptr = MUStrTok(NULL,", \t",&TokPtr);
}
}
RQ[0]->SetList[index] = NULL;
} /* END if ((ptr = MUStrTok(NULL)) != NULL) */
} /* END if ((ptr = MUStrTok(SetString)) != NULL) */
} /* END if ((SetString[0] != '0') && (strcmp(SetString,NONE))) */
if (MJobEval(J) == FAILURE)
{
/* job not properly formed */
DBG(1,fSTRUCT) DPrint("ALERT: ignoring job '%s' with corrupt configuration\n",
J->Name);
MJobDestroy(&J);
return(FAILURE);
}
DBG(6,fSIM) DPrint("INFO: job '%s' loaded. class: %s opsys: %s arch: %s\n",
J->Name,
MUCAListToString(RQ[0]->DRes.PSlot,NULL,NULL),
MAList[eOpsys][RQ[0]->Opsys],
MAList[eArch][RQ[0]->Arch]);
return(SUCCESS);
} /* END MTraceLoadWorkload() */
int MCfgGetSList(
char *Buf,
char **CurPtr,
const char *Parm,
char *IndexName,
int *Index,
int Length,
char *Value,
char *SymTable[])
{
int index;
char ValLine[MAX_MLINE];
char *ptr;
char *TokPtr;
int rc;
const char *FName = "MCfgGetSList";
DBG(7,fCONFIG) DPrint("%s(Buf,CurPtr,%s,%s,Index,%d,Value,SymTable)\n",
FName,
Parm,
IndexName,
Length);
ptr = Buf;
if (CurPtr != NULL)
ptr = MAX(ptr,*CurPtr);
rc = MCfgGetVal(&ptr,Parm,IndexName,Index,ValLine,sizeof(ValLine),SymTable);
if (rc == FAILURE)
{
return(FAILURE);
}
index = 0;
ptr = MUStrTok(ValLine," :;",&TokPtr);
while (ptr != NULL)
{
strncpy(&Value[index * Length],ptr,Length);
Value[((index + 1) * Length) - 1] = '\0';
index++;
ptr = MUStrTok(NULL," :;",&TokPtr);
}
Value[index * Length] = '\0';
for (index = 0;Value[index * Length] != '\0';index++)
{
DBG(4,fCONFIG) DPrint("INFO: %s[%d][%d] set to '%s'\n",
Parm,
*Index,
index,
&Value[index * Length]);
}
return(SUCCESS);
} /* END MCfgGetSList() */
