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 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 MASLSJobConfig(
mjob_t *J,
char *ConfigString)
{
char *ptr;
char *TokPtr;
int aindex;
char ValLine[MAX_MLINE];
char tmpLine[MAX_MLINE];
int index;
maslsdata_t *D;
if ((J == NULL) || (ConfigString == NULL))
{
return(FAILURE);
}
D = (maslsdata_t *)J->ASData;
if (D == NULL)
return(FAILURE);
/* process config data */
/* FORMAT: INPUT=<INPUTDATANAME>:<INPUTDATASIZE>;OUTPUT=<OUTPUTDATANAME>:<OUTPUTDATASIZE>;STATE=<STATE>; */
ptr = MUStrTok(ConfigString,"; \t\n",&TokPtr);
while (ptr != NULL)
{
if (MUGetPair(
ptr,
(const char **)MASLSAttributeType,
&aindex,
NULL,
TRUE,
NULL,
ValLine,
MAX_MNAME) == FAILURE)
{
/* cannot parse value pair */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
continue;
}
switch(aindex)
{
case maslsaState:
index = MUGetIndex(ValLine,MJobState,0,0);
switch(index)
{
case mjsStarting:
case mjsRunning:
if ((D->ASState != mjsStarting) && (D->ASState != mjsRunning))
{
if ((D->IFileSize > 0) && (D->INetRes->Func != NULL))
{
/* initiate stagein transaction */
sprintf(tmpLine,"FILE+=%s:%d",
D->IFileName,
D->IFileSize);
(*D->INetRes->Func)(
&D->INetRes->Data,
mascConfig,
tmpLine,
(void **)&D->IStageTime);
}
D->ASState = index;
}
break;
default:
/* NO-OP */
break;
} /* END switch(index) */
break;
default:
/* NO-OP */
break;
} /* END switch(aindex) */
ptr = MUStrTok(NULL,"; \t\n",&TokPtr);
} /* END while (ptr != NULL) */
return(SUCCESS);
} /* END MASLSJobConfig() */
int MNodeProcessConfig(
mnode_t *N, /* I (modified) */
mrm_t *R, /* I (optional) */
char *Value) /* I (modified) */
{
char *ptr;
char *TokPtr;
char *ptr2;
char ValBuf[MMAX_BUFFER];
char AttrArray[MMAX_NAME];
int aindex;
enum MNodeAttrEnum AIndex;
int tmpInt;
int tmpI;
double tmpD;
int SlotsUsed = -1;
int rc;
enum MObjectSetModeEnum CIndex;
mbool_t FailureDetected;
const char *FName = "MNodeProcessConfig";
MDB(5,fSTRUCT) MLog("%s(%s,%s,%s)\n",
FName,
(N != NULL) ? N->Name : "NULL",
(R != NULL) ? R->Name : "NULL",
(Value != NULL) ? Value : "NULL");
if ((N == NULL) ||
(Value == NULL) ||
(Value[0] == '\0'))
{
return(FAILURE);
}
ptr = MUStrTokE(Value," \t\n",&TokPtr);
FailureDetected = FALSE;
while (ptr != NULL)
{
/* parse name-value pairs */
/* FORMAT: <ATTR>=<VALUE>[,<VALUE>] */
if (MUGetPair(
ptr,
(const char **)MNodeAttr,
&aindex, /* O */
AttrArray,
TRUE,
&tmpI, /* O */
ValBuf, /* O */
MMAX_BUFFER) == FAILURE)
{
char tmpLine[MMAX_LINE];
/* cannot parse value pair */
snprintf(tmpLine,sizeof(tmpLine),"unknown attribute '%.128s' specified",
ptr);
MDB(3,fSTRUCT) MLog("WARNING: unknown attribute '%s' specified for node %s\n",
ptr,
(N != NULL) ? N->Name : "NULL");
MMBAdd(&N->MB,tmpLine,NULL,mmbtNONE,0,0,NULL);
ptr = MUStrTokE(NULL," \t\n",&TokPtr);
continue;
}
rc = SUCCESS;
AIndex = (enum MNodeAttrEnum)aindex;
switch (tmpI)
{
case 1:
CIndex = mIncr;
break;
case -1:
CIndex = mDecr;
break;
case 0:
default:
CIndex = mSet;
break;
} /* END switch (CIndex) */
switch (AIndex)
{
case mnaAccess:
case mnaAccountList:
case mnaArch:
case mnaCfgClass:
case mnaClassList:
case mnaFlags:
case mnaGroupList:
case mnaJTemplateList:
case mnaNodeIndex:
case mnaPowerPolicy:
case mnaMaxProcPerClass:
case mnaProvRM:
case mnaQOSList:
case mnaUserList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,CIndex);
break;
case mnaComment:
/* add as node message */
{
mmb_t *MB;
MMBAdd(
&N->MB,
(char *)ValBuf,
MSCHED_SNAME,
mmbtAnnotation,
MMAX_TIME,
0,
&MB);
if (MB != NULL)
MUStrDup(&MB->Label,"comment");
} /* END BLOCK (case mnaComment) */
break;
case mnaAvlClass:
if (!bmisset(&N->IFlags,mnifRMClassUpdate))
{
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
}
break;
case mnaAvlMemW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcAMem] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaAvlProcW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcAProcs] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCMem:
{
bmunset(&N->IFlags,mnifMemOverride); /* unset so that new values can be set dynamically */
MNodeSetAttr(N,mnaRCMem,(void **)ValBuf,mdfString,mSet);
if (ValBuf[strlen(ValBuf) - 1] == '^')
bmset(&N->IFlags,mnifMemOverride);
}
break;
case mnaCfgMemW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcCMem] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCProc:
N->CRes.Procs = (int)strtol(ValBuf,NULL,10);
break;
case mnaCfgProcW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcCProcs] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaRCSwap:
{
bmunset(&N->IFlags,mnifSwapOverride); /* unset so that value can be set dynamically */
MNodeSetAttr(N,mnaRCSwap,(void **)ValBuf,mdfString,mSet);
if (ValBuf[strlen(ValBuf) - 1] == '^')
bmset(&N->IFlags,mnifSwapOverride);
}
break;
case mnaFailure:
{
char *ptr;
char *TokPtr;
int findex;
enum MNodeFailEnum {
mnfNONE,
mnfState,
mnfMem,
mnfSwap,
mnfLoad };
const char *NFType[] = {
NONE,
"STATE",
"MEM",
"SWAP",
"LOAD",
NULL };
ptr = MUStrTok(ValBuf,",",&TokPtr);
while (ptr != NULL)
{
findex = MUGetIndex(ptr,NFType,FALSE,0);
switch (findex)
{
case mnfState:
MNodeSetState(N,mnsDown,FALSE);
if (N->Message == NULL)
{
MUStrDup(&N->Message,"node is down");
}
break;
case mnfMem:
tmpInt = 0;
MNodeSetAttr(N,mnaRAMem,(void **)&tmpInt,mdfInt,mSet);
MUStrDup(&N->Message,"memory is low");
break;
case mnfSwap:
tmpInt = 3;
MNodeSetAttr(N,mnaRASwap,(void **)&tmpInt,mdfInt,mSet);
MUStrDup(&N->Message,"swap is low");
break;
case mnfLoad:
N->ARes.Procs = 0;
N->Load = 4.3;
MUStrDup(&N->Message,"excessive processor usage");
break;
case mnfNONE:
default:
/* NO-OP */
break;
} /* END switch (findex) */
ptr = MUStrTok(NULL,",",&TokPtr);
} /* END while (ptr != NULL) */
} /* END BLOCK */
break;
case mnaFeatures:
{
char tmpBuffer[MMAX_BUFFER];
char *TokPtr2;
/* FORMAT: <FEATURE>[{ ,:}<FEATURE>]... */
/* NOTE: Mode == mDecr NOT supported */
/* if '!' specified, update named feature */
/* NOTE: if features specified via config file, should be appended to features
discovered via RM */
MSched.NodeFeaturesSpecifiedInConfig = TRUE;
if (CIndex == mSet)
{
bmclear(&N->FBM);
}
strcpy(tmpBuffer,ValBuf);
ptr2 = MUStrTok(tmpBuffer,":, \t\n",&TokPtr2);
while (ptr2 != NULL)
{
MNodeProcessFeature(N,ptr2);
ptr2 = MUStrTok(NULL,":, \t\n",&TokPtr2);
} /* END while (ptr != NULL) */
} /* END BLOCK (case mnaFeatures) */
/* Moab owns feature indicated by clearing RM ownership bit */
bmunset(&N->RMAOBM,mnaFeatures);
break;
case mnaCfgGRes:
case mnaChargeRate:
case mnaEnableProfiling:
if (MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet) == FAILURE)
{
/* complete or partial failure setting attribute */
/* NO-OP */
}
break;
case mnaKbdDetectPolicy:
case mnaKbdIdleTime:
case mnaMinPreemptLoad:
case mnaMinResumeKbdIdleTime:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaLoadW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcLoad] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaLogLevel:
N->LogLevel = (int)strtol(ValBuf,NULL,10);
break;
case mnaMaxJob:
{
tmpI = (int)strtol(ValBuf,NULL,10);
if (AttrArray[0] == '\0')
{
N->AP.HLimit[mptMaxJob] = tmpI;
}
else
{
/* NYI */
}
} /* END BLOCK */
break;
case mnaMaxProc:
{
tmpI = (int)strtol(ValBuf,NULL,10);
if (AttrArray[0] == '\0')
{
N->AP.HLimit[mptMaxProc] = tmpI;
}
} /* END BLOCK */
break;
case mnaMaxJobPerGroup:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxJobPerGroup = tmpI;
break;
case mnaMaxJobPerUser:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxJobPerUser = tmpI;
break;
case mnaMaxLoad:
case mnaMaxWCLimitPerJob:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaMaxProcPerGroup:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxProcPerGroup = tmpI;
break;
case mnaMaxProcPerUser:
tmpI = (int)strtol(ValBuf,NULL,10);
if (N->NP == NULL)
{
if ((N->NP = (mnpolicy_t *)MUCalloc(1,sizeof(mnpolicy_t))) == NULL)
break;
}
N->NP->MaxProcPerUser = tmpI;
break;
case mnaMaxWatts:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaOS:
case mnaOSList:
case mnaVMOSList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaNodeType:
MUStrDup(&N->NodeType,ValBuf);
break;
case mnaResOvercommitFactor:
case mnaAllocationLimits:
if (N->ResOvercommitFactor == NULL)
{
if ((N->ResOvercommitFactor = (double *)MUCalloc(1,sizeof(double) * mrlLAST)) == NULL)
{
return(FAILURE);
}
}
MUResFactorArrayFromString((char *)ValBuf,N->ResOvercommitFactor,NULL,TRUE,FALSE);
break;
case mnaResOvercommitThreshold:
case mnaUtilizationThresholds:
if (N->ResOvercommitThreshold == NULL)
{
if ((N->ResOvercommitThreshold = (double *)MUCalloc(1,sizeof(double) * mrlLAST)) == NULL)
{
return(FAILURE);
}
}
if (N->GMetricOvercommitThreshold == NULL)
{
int gmindex;
if ((N->GMetricOvercommitThreshold = (double *)MUCalloc(1,sizeof(double) * MSched.M[mxoxGMetric])) == NULL)
{
return(FAILURE);
}
/* initialize all thresholds to 'unset' value */
for (gmindex = 0;gmindex < MSched.M[mxoxGMetric]; gmindex++)
{
N->GMetricOvercommitThreshold[gmindex] = MDEF_GMETRIC_VALUE;
}
}
MUResFactorArrayFromString((char *)ValBuf,N->ResOvercommitThreshold,N->GMetricOvercommitThreshold,TRUE,FALSE);
break;
case mnaOwner:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaPartition:
case mnaPreemptMaxCPULoad:
case mnaPreemptMinMemAvail:
case mnaPreemptPolicy:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaPrioF:
{
mnprio_t *tmpPriorityFunc = NULL;
if (MProcessNAPrioF(&tmpPriorityFunc,ValBuf) == FAILURE)
{
MNPrioFree(&tmpPriorityFunc);
return(FAILURE);
}
/* clear out existing priority function */
MNPrioFree(&N->P);
N->P = tmpPriorityFunc;
} /* END BLOCK */
break;
case mnaPriority:
N->Priority = (int)strtol(ValBuf,NULL,10);
N->PrioritySet = TRUE;
break;
case mnaPrioW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcPriority] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaProcSpeed:
tmpI = (int)strtol(ValBuf,NULL,10);
N->ProcSpeed = tmpI;
break;
case mnaRack:
{
/* FORMAT: <RACKINDEX>|<RACKNAME> */
if (isdigit(ValBuf[0]))
{
tmpI = (int)strtol(ValBuf,NULL,10);
}
else
{
if (MRackAdd(ValBuf,&tmpI,NULL) == FAILURE)
{
/* cannot add rack */
break;
}
}
rc = MNodeSetAttr(N,mnaRack,(void **)&tmpI,mdfInt,mSet);
} /* END BLOCK */
break;
case mnaRADisk:
case mnaRCDisk:
case mnaMaxPE:
case mnaMaxPEPerJob:
case mnaRMList:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
case mnaSize:
tmpI = (int)strtol(ValBuf,NULL,10);
SlotsUsed = tmpI;
break;
case mnaSlot:
rc = MNodeSetAttr(N,mnaSlot,(void **)ValBuf,mdfString,mSet);
break;
case mnaSpeed:
tmpD = strtod(ValBuf,NULL);
if (tmpD == 0.0)
{
tmpD = 0.01;
}
N->Speed = MIN(100.0,tmpD);
break;
case mnaSpeedW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcSpeed] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
case mnaTrigger:
{
marray_t TList;
int tindex;
mtrig_t *T;
MUArrayListCreate(&TList,sizeof(mtrig_t *),4);
MTrigLoadString(&N->T,ValBuf,TRUE,FALSE,mxoNode,N->Name,&TList,NULL);
if (N->T != NULL)
{
for (tindex = 0;tindex < TList.NumItems;tindex++)
{
T = (mtrig_t *)MUArrayListGetPtr(&TList,tindex);
if (MTrigIsValid(T) == FALSE)
continue;
MTrigInitialize(T);
} /* END for (tindex) */
}
MUArrayListFree(&TList);
} /* END BLOCK mnaTrigger */
break;
case mnaUsageW:
if ((N->P != NULL) ||
(MNPrioAlloc(&N->P) == SUCCESS))
{
N->P->CW[mnpcUsage] = strtod(ValBuf,NULL);
N->P->CWIsSet = TRUE;
}
break;
#if 0
/* this is not used anywhere */
case mnaResource:
/* FORMAT: <RESNAME>:<RESCOUNT>[,<RESNAME>:<RESCOUNT>]... */
{
char *ptr;
char *TokPtr;
ptr = MUStrTok(ValBuf,", \t",&TokPtr);
while (ptr != NULL)
{
/* FORMAT: <RESDESC>[{ \t,}<RESDESC]... */
MNodeSetAttr(N,mnaCfgGRes,(void **)ptr,mdfString,mSet);
ptr = MUStrTok(NULL,", \t",&TokPtr);
}
} /* END BLOCK */
break;
#endif
case mnaVariables:
MNodeSetAttr(N,AIndex,(void **)ValBuf,mdfString,mSet);
break;
default:
/* NO-OP */
break;
} /* END switch (AIndex) */
if (rc == FAILURE)
FailureDetected = TRUE;
ptr = MUStrTokE(NULL," \t\n",&TokPtr);
} /* END while (ptr != NULL) */
if (FailureDetected == TRUE)
{
return(FAILURE);
}
/* sync 'side-effects' */
if (SlotsUsed > 0)
{
N->SlotsUsed = SlotsUsed;
if ((N->RackIndex > 0) && (N->SlotIndex > 0))
MSys[N->RackIndex][N->SlotIndex].SlotsUsed = SlotsUsed;
}
return(SUCCESS);
} /* END MNodeProcessConfig() */
int MVCFromXML(
mvc_t *VC, /* I (modified) */
mxml_t *E) /* I */
{
mcredl_t *L = NULL;
int aindex;
enum MVCAttrEnum saindex;
mxml_t *CE = NULL;
int CTok;
if ((VC == NULL) || (E == NULL))
{
return(FAILURE);
}
for (aindex = 0;aindex < E->ACount;aindex++)
{
saindex = (enum MVCAttrEnum)MUGetIndex(E->AName[aindex],MVCAttr,FALSE,0);
if (saindex == mvcaNONE)
continue;
if ((saindex == mvcaThrottlePolicies) &&
(MVCGetDynamicAttr(VC,mvcaThrottlePolicies,(void **)&L,mdfOther) == FAILURE))
{
L = (mcredl_t *)MUCalloc(1,sizeof(mcredl_t));
MPUInitialize(&L->ActivePolicy);
MVCSetDynamicAttr(VC,mvcaThrottlePolicies,(void **)&L,mdfOther);
}
MVCSetAttr(VC,saindex,(void **)E->AVal[aindex],mdfString,mSet);
}
CTok = -1;
if (MXMLGetChild(E,"Variables",&CTok,&CE) == SUCCESS)
{
MUAddVarsFromXML(CE,&VC->Variables);
}
CTok = -1;
if (MXMLGetChild(E,MVCAttr[mvcaMessages],&CTok,&CE) == SUCCESS)
{
MMBFromXML(&VC->MB,CE);
}
CTok = -1;
while (MXMLGetChild(E,(char *)MVCAttr[mvcaACL],&CTok,&CE) == SUCCESS)
{
/* ACL's */
MACLFromXML(&VC->ACL,CE,FALSE);
}
MVCTransition(VC);
return(SUCCESS);
} /* END MVCFromXML() */
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 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 MWikiSDUpdateAttr(
char *AttrString, /* I */
msdata_t *SD, /* I (modified) */
mrm_t *R, /* I (optional) */
char *EMsg) /* O (optional,minsize=MMAX_LINE) */
{
char *ptr;
char *Value;
char tmpLine[MMAX_LINE];
char *TokPtr;
int aindex;
const char *FName = "MWikiSDUpdateAttr";
MDB(6,fWIKI) MLog("%s(%.32s,SD,R,EMsg)\n",
FName,
(AttrString != NULL) ? AttrString : "NULL");
if (EMsg != NULL)
EMsg[0] = '\0';
if ((SD == NULL) || (AttrString == NULL))
{
return(FAILURE);
}
if ((ptr = MUStrChr(AttrString,'=')) == NULL)
{
if (EMsg != NULL)
{
snprintf(EMsg,MMAX_LINE,"attribute '%s' malformed - no '='",
AttrString);
}
return(FAILURE);
}
/* FORMAT: <ATTR>={"<ALNUM_STRING>"|<ALNUM_STRING>} */
/* make copy of attribute string */
MUStrCpy(tmpLine,AttrString,sizeof(tmpLine));
ptr = MUStrTokE(tmpLine,"=",&TokPtr);
aindex = MUGetIndex(ptr,MWikiSDAttr,FALSE,0);
if (aindex == 0)
{
if (EMsg != NULL)
{
snprintf(EMsg,MMAX_LINE,"invalid attribute '%s' specified",
AttrString);
}
return(FAILURE);
}
Value = MUStrTokE(NULL,"=",&TokPtr);
if (Value == NULL)
{
snprintf(EMsg,MMAX_LINE,"missing value for attribute '%s'",
AttrString);
return(FAILURE);
}
switch (aindex)
{
case mwsdaBytesTransferred:
{
mulong NewSize;
NewSize = strtol(Value,NULL,10);
if (NewSize != SD->DstFileSize)
{
/* mark that the staging operating is not stalled */
SD->UTime = MSched.Time;
}
MSDSetAttr(SD,msdaDstFileSize,(void **)&NewSize,mdfLong,mSet);
} /* END BLOCK */
break;
case mwsdaEndTime:
/* data staging operation has finished? */
/* NYI */
break;
case mwsdaError:
MUStrDup(&SD->EMsg,Value);
break;
case mwsdaFileSize:
{
mulong tmpL = strtol(Value,NULL,10);
MSDSetAttr(SD,msdaSrcFileSize,(void **)&tmpL,mdfLong,mSet);
} /* END BLOCK */
break;
case mwsdaRemoveTime:
/* NYI */
break;
case mwsdaSourceURL:
/* verify that this URL matches what we expect */
if (strcmp(SD->SrcLocation,Value))
{
/* URL's do not match - mismatched record! */
MDB(2,fWIKI) MLog("WARNING: stage-data src location is being incorrectly reported via WIKI '%s' != '%s'\n",
Value,
SD->SrcLocation);
return(FAILURE);
}
break;
case mwsdaStartTime:
{
mulong tmpL = strtol(Value,NULL,10);
MSDSetAttr(SD,msdaTStartDate,(void **)&tmpL,mdfLong,mSet);
} /* END BLOCK */
break;
case mwsdaState:
MSDSetAttr(SD,msdaState,(void **)Value,mdfString,mSet);
break;
case mwsdaUser:
/* NYI */
break;
default:
MDB(2,fWIKI) MLog("INFO: WIKI keyword '%s'(%d) not handled\n",
MWikiSDAttr[aindex],
aindex);
return(FAILURE);
/*NOTREACHED*/
break;
} /* END switch (aindex) */
return(SUCCESS);
} /* END MWikiSDUpdateAttr() */
int MRMFromXML(
mrm_t *R, /* I (modified) */
mxml_t *E) /* I */
{
int aindex;
enum MRMAttrEnum raindex;
int pindex;
int CTok;
mxml_t *CE;
const char *FName = "MRMFromXML";
MDB(3,fSTRUCT) MLog("%s(%s,%s)\n",
FName,
(R != NULL) ? "R" : "NULL",
(E != NULL) ? "E" : "NULL");
if ((R == NULL) || (E == NULL))
{
return(FAILURE);
}
/* NOTE: do not initialize--may be overlaying existing data */
for (aindex = 0;aindex < E->ACount;aindex++)
{
raindex = (enum MRMAttrEnum)MUGetIndex(E->AName[aindex],MRMAttr,FALSE,0);
if (raindex == mrmaNONE)
continue;
MRMSetAttr(R,raindex,(void **)E->AVal[aindex],mdfString,mSet);
} /* END for (aindex) */
if (MXMLGetChild(E,(char *)MXO[mxoQueue],NULL,&CE) == SUCCESS)
{
/* NOTE: We may want to look at making this dynamic. It's only a matter of time
before somebody else blows this buffer again. */
char Buffer[MMAX_BUFFER<<4];
/* load jobs from the internal queue */
if (MXMLGetAttr(CE,(char *)MXO[mxoJob],NULL,Buffer,sizeof(Buffer)) == SUCCESS)
{
MS3InitializeLocalQueue(R,Buffer);
}
}
CTok = -1;
pindex = 0;
while (MXMLGetChild(E,"psi",&CTok,&CE) == SUCCESS)
{
/* set default */
if (R->P[pindex].Type == mpstNONE)
R->P[pindex].Type = mpstQM;
MPSIFromXML(&R->P[pindex++],CE);
}
return(SUCCESS);
} /* END MRMFromXML() */
