static void
prtHostsShort (int numReply, struct hostInfoEnt *hInfo)
{
struct hostInfoEnt *hPtr;
int i;
char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
char first = TRUE;
for (i = 0; i < numReply; i++) {
hPtr = &(hInfo[i]);
if ( first ) {
first = FALSE;
prtWord(HOST_NAME_LENGTH,
_i18n_msg_get(ls_catd, NL_SETN, 1618, "HOST_NAME"), 0); /* catgets 1618 */
if ( wflag )
prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);
else
prtWord(HOST_STATUS_SHORT, I18N_STATUS, 0);
if (lsbMode_ & LSB_MODE_BATCH)
prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
prtWord(HOST_MAX_LENGTH, I18N_MAX, -1);
prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(HOST_RUN_LENGTH, I18N_RUN, -1);
prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
prtWord(HOST_RSV_LENGTH, I18N_RSV, -1);
printf("\n");
};
if ( repeatHost (i, hInfo) )
continue;
if ( wflag )
prtWordL(HOST_NAME_LENGTH, hPtr->host);
else
prtWord(HOST_NAME_LENGTH, hPtr->host, 0);
status = I18N_ok;
if (hPtr->hStatus & HOST_STAT_UNAVAIL)
status = I18N_unavail;
else if (hPtr->hStatus & HOST_STAT_UNREACH)
status = (_i18n_msg_get(ls_catd,NL_SETN,1626, "unreach")); /* catgets 1626 */
else if (hPtr->hStatus & (HOST_STAT_BUSY
| HOST_STAT_WIND
| HOST_STAT_DISABLED
| HOST_STAT_EXCLUSIVE
| HOST_STAT_LOCKED
| HOST_STAT_LOCKED_MASTER
| HOST_STAT_FULL
| HOST_STAT_NO_LIM)) {
if ( !wflag )
status = (_i18n_msg_get(ls_catd,NL_SETN,1627, "closed")); /* catgets 1627 */
else
getCloseString (hPtr->hStatus, &status);
};
if ( hPtr->userJobLimit < INFINIT_INT )
strcpy(userJobLimit,
prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
else
strcpy(userJobLimit, prtDash(HOST_JL_U_LENGTH));
if ( hPtr->maxJobs < INFINIT_INT )
strcpy(maxJobs,
prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
else
strcpy(maxJobs, prtDash(HOST_MAX_LENGTH));
if ( wflag )
prtWordL(HOST_STATUS_LENGTH, status);
else
prtWordL(HOST_STATUS_SHORT, status);
if ( lsbMode_ & LSB_MODE_BATCH )
printf("%s", userJobLimit);
sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd\n",
HOST_NJOBS_LENGTH,
HOST_RUN_LENGTH,
HOST_SSUSP_LENGTH,
HOST_USUSP_LENGTH,
HOST_RSV_LENGTH);
printf(fomt,
maxJobs,
hPtr->numJobs,
hPtr->numRUN, hPtr->numSSUSP, hPtr->numUSUSP,
hPtr->numRESERVE);
}
}
static void
prtQueuesShort(int numQueues, struct queueInfoEnt *queueInfo)
{
struct queueInfoEnt *qp;
char statusStr[64];
char first = FALSE;
int i;
char userJobLimit[MAX_CHARLEN],
procJobLimit[MAX_CHARLEN],
hostJobLimit[MAX_CHARLEN];
char maxJobs[MAX_CHARLEN];
if( !first ) {
prtWord(QUEUE_NAME_LENGTH, I18N_QUEUE__NAME, 0);
prtWord(QUEUE_PRIO_LENGTH, I18N_PRIO, 1);
prtWord(QUEUE_STATUS_LENGTH, I18N_STATUS, 0);
if ( lsbMode_ & LSB_MODE_BATCH ) {
prtWord(QUEUE_MAX_LENGTH, I18N_MAX, -1);
prtWord(QUEUE_JL_U_LENGTH, I18N_JL_U, -1);
prtWord(QUEUE_JL_P_LENGTH, I18N_JL_P, -1);
prtWord(QUEUE_JL_H_LENGTH, I18N_JL_H, -1);
};
prtWord(QUEUE_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(QUEUE_PEND_LENGTH, I18N_PEND, -1);
prtWord(QUEUE_RUN_LENGTH, I18N_RUN, -1);
prtWord(QUEUE_SUSP_LENGTH, I18N_SUSP, -1);
printf("\n");
first = TRUE;
}
for ( i=0; i<numQueues; i++) {
qp = &(queueInfo[i]);
if (qp->qStatus & QUEUE_STAT_OPEN) {
sprintf(statusStr, "%s:", I18N_Open);
}
else {
sprintf(statusStr, "%s:", I18N_Closed);
}
if (qp->qStatus & QUEUE_STAT_ACTIVE) {
if (qp->qStatus & QUEUE_STAT_RUN) {
strcat(statusStr, I18N_Active);
} else {
strcat(statusStr, I18N_Inact);
}
} else {
strcat(statusStr, I18N_Inact);
}
if (qp->maxJobs < INFINIT_INT)
strcpy(maxJobs, prtValue(QUEUE_MAX_LENGTH, qp->maxJobs) );
else
strcpy(maxJobs, prtDash(QUEUE_MAX_LENGTH) );
if (qp->userJobLimit < INFINIT_INT)
strcpy(userJobLimit,
prtValue(QUEUE_JL_U_LENGTH, qp->userJobLimit) );
else
strcpy(userJobLimit, prtDash(QUEUE_JL_U_LENGTH) );
if (qp->procJobLimit < INFINIT_FLOAT) {
sprintf(fomt, "%%%d.0f ", QUEUE_JL_P_LENGTH);
sprintf (procJobLimit, fomt, qp->procJobLimit);
}
else
strcpy(procJobLimit, prtDash(QUEUE_JL_P_LENGTH) );
if (qp->hostJobLimit < INFINIT_INT)
strcpy(hostJobLimit,
prtValue(QUEUE_JL_H_LENGTH, qp->hostJobLimit) );
else
strcpy(hostJobLimit, prtDash(QUEUE_JL_H_LENGTH) );
if (wflag) {
prtWordL(QUEUE_NAME_LENGTH, qp->queue);
prtWordL(QUEUE_PRIO_LENGTH,
prtValue(3, qp->priority));
prtWordL(QUEUE_STATUS_LENGTH, statusStr);
} else {
prtWord(QUEUE_NAME_LENGTH, qp->queue, 0);
prtWord(QUEUE_PRIO_LENGTH,
prtValue(3, qp->priority), 1);
prtWord(QUEUE_STATUS_LENGTH, statusStr, 1);
}
if ( lsbMode_ & LSB_MODE_BATCH ) {
sprintf(fomt, "%%%ds%%%ds%%%ds%%%ds", QUEUE_MAX_LENGTH,
QUEUE_JL_U_LENGTH,
QUEUE_JL_P_LENGTH,
QUEUE_JL_H_LENGTH );
printf(fomt,
maxJobs, userJobLimit, procJobLimit, hostJobLimit);
}
sprintf(fomt, "%%%dd %%%dd %%%dd %%%dd\n", QUEUE_NJOBS_LENGTH,
QUEUE_PEND_LENGTH,
QUEUE_RUN_LENGTH,
QUEUE_SUSP_LENGTH );
printf(fomt,
qp->numJobs, qp->numPEND, qp->numRUN,
(qp->numSSUSP + qp->numUSUSP) );
}
}
static void
prtHostsLong (int numReply, struct hostInfoEnt *hInfo)
{
struct hostInfoEnt *hPtr;
int i, j, retVal = 0;
char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
char **nameTable, **totalValues, **rsvValues, **formats;
struct lsInfo *lsInfo;
if ((lsInfo = ls_info()) == NULL) {
ls_perror("ls_info");
exit(-1);
}
lsInfoPtr = lsInfo;
for (i = 0; i < numReply; i++) {
hPtr = &(hInfo[i]);
if (repeatHost (i, hInfo))
continue;
printf("%s %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1604, "HOST")), /* catgets 1604 */
hPtr->host);
prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);
if (lsbMode_ & LSB_MODE_BATCH) {
prtWord(HOST_CPUF_LENGTH, I18N_CPUF, -1);
prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
};
prtWord(HOST_MAX_LENGTH, I18N_MAX, -1);
prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(HOST_RUN_LENGTH, I18N_RUN, -1);
prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
prtWord(HOST_RSV_LENGTH, I18N_RSV, -1);
if (lsbMode_ & LSB_MODE_BATCH)
printf(I18N(1608, "DISPATCH_WINDOW\n")); /* catgets 1608 */
else
printf("\n");
status = I18N_ok;
if (hPtr->hStatus & HOST_STAT_UNAVAIL)
status = I18N_unavail;
else if (hPtr->hStatus & HOST_STAT_UNREACH)
status = (_i18n_msg_get(ls_catd,NL_SETN,1611, "unreach")); /* catgets 1611 */
else if (hPtr->hStatus & (HOST_STAT_BUSY
| HOST_STAT_WIND
| HOST_STAT_DISABLED
| HOST_STAT_EXCLUSIVE
| HOST_STAT_LOCKED
| HOST_STAT_LOCKED_MASTER
| HOST_STAT_FULL
| HOST_STAT_NO_LIM))
getCloseString (hPtr->hStatus, &status);
if (hPtr->userJobLimit < INFINIT_INT)
strcpy(userJobLimit,
prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
else
strcpy(userJobLimit, prtDash(HOST_JL_U_LENGTH));
if ( hPtr->maxJobs < INFINIT_INT )
strcpy(maxJobs,
prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
else
strcpy(maxJobs, prtDash(HOST_MAX_LENGTH));
prtWordL(HOST_STATUS_LENGTH, status);
if (lsbMode_ & LSB_MODE_BATCH) {
sprintf(fomt, "%%%d.2f %%s", HOST_CPUF_LENGTH );
printf(fomt, hPtr->cpuFactor, userJobLimit);
};
sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd ",
HOST_NJOBS_LENGTH,
HOST_RUN_LENGTH,
HOST_SSUSP_LENGTH,
HOST_USUSP_LENGTH,
HOST_RSV_LENGTH);
printf(fomt,
maxJobs, hPtr->numJobs, hPtr->numRUN,
hPtr->numSSUSP, hPtr->numUSUSP, hPtr->numRESERVE);
if (lsbMode_ & LSB_MODE_BATCH)
printf("%s\n\n",
hPtr->windows[0] != '\0' ? hPtr->windows : " -");
else
printf("\n\n");
if (!(hPtr->hStatus & (HOST_STAT_UNAVAIL | HOST_STAT_UNREACH))){
printf(" %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1612, "CURRENT LOAD USED FOR SCHEDULING")); /* catgets 1612 */
prtLoad(hPtr, lsInfo);
if (lsbSharedResConfigured_) {
retVal = makeShareFields(hPtr->host, lsInfo, &nameTable,
&totalValues, &rsvValues,
&formats);
if (retVal > 0) {
int start =0;
int end;
while ((end = getDispLastItem(nameTable, start, retVal)) > start
&& start < retVal) {
printf(" %11s", " ");
for (j = start; j < end; j++)
printf(formats[j], nameTable[j]);
printf("\n %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1613, "Total")); /* catgets 1613 */
for (j = start; j < end; j++)
printf(formats[j], totalValues[j]);
printf("\n %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1614, "Reserved")); /* catgets 1614 */
for (j = start; j < end; j++)
printf(formats[j], rsvValues[j]);
putchar('\n');
putchar('\n');
start = end;
}
putchar('\n');
}
}
}
printf(" %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1615, "LOAD THRESHOLD USED FOR SCHEDULING")); /* catgets 1615 */
if (printThresholds(hPtr->loadSched, hPtr->loadStop,
hPtr->busySched, hPtr->busyStop,
MIN(hInfo->nIdx, lsInfo->numIndx),
lsInfo) < 0)
continue;
printf("\n");
if (hPtr->mig < INFINIT_INT)
printf(( _i18n_msg_get(ls_catd, NL_SETN, 1616, "Migration threshold is %d min \n")), hPtr->mig); /* catgets 1616 */
printf("\n");
}
}
static void
prtQueuesLong(int numQueues, struct queueInfoEnt *queueInfo)
{
struct queueInfoEnt *qp;
char statusStr[64];
char userJobLimit[MAX_CHARLEN];
char procJobLimit[MAX_CHARLEN];
char hostJobLimit[MAX_CHARLEN];
char maxJobs[MAX_CHARLEN];
int i;
int numDefaults = 0;
struct lsInfo *lsInfo;
int printFlag = 0;
int printFlag1 = 0;
int printFlag2 = 0;
int procLimits[3];
if ((lsInfo = ls_info()) == NULL) {
ls_perror("ls_info");
exit(-1);
}
printf("\n");
for (i = 0; i < numQueues; i++ ) {
qp = &(queueInfo[i]);
if (qp->qAttrib & Q_ATTRIB_DEFAULT)
numDefaults++;
}
for (i = 0; i < numQueues; i++) {
qp = &(queueInfo[i]);
if (qp->qStatus & QUEUE_STAT_OPEN) {
sprintf(statusStr, "%s:", I18N_Open);
}
else {
sprintf(statusStr, "%s:", I18N_Closed);
}
if (qp->qStatus & QUEUE_STAT_ACTIVE) {
if (qp->qStatus & QUEUE_STAT_RUN) {
strcat(statusStr, I18N_Active);
} else {
strcat(statusStr, I18N_Inact__Win);
}
} else {
strcat(statusStr, I18N_Inact__Adm);
}
if (qp->maxJobs < INFINIT_INT)
strcpy(maxJobs, prtValue(QUEUE_MAX_LENGTH, qp->maxJobs) );
else
strcpy(maxJobs, prtDash(QUEUE_MAX_LENGTH) );
if (qp->userJobLimit < INFINIT_INT)
strcpy(userJobLimit,
prtValue(QUEUE_JL_U_LENGTH, qp->userJobLimit) );
else
strcpy(userJobLimit, prtDash(QUEUE_JL_U_LENGTH) );
if (qp->procJobLimit < INFINIT_FLOAT) {
sprintf(fomt, "%%%d.1f ", QUEUE_JL_P_LENGTH);
sprintf (procJobLimit, fomt, qp->procJobLimit);
}
else
strcpy(procJobLimit, prtDash(QUEUE_JL_P_LENGTH) );
if (qp->hostJobLimit < INFINIT_INT)
strcpy(hostJobLimit,
prtValue(QUEUE_JL_H_LENGTH, qp->hostJobLimit) );
else
strcpy(hostJobLimit, prtDash(QUEUE_JL_H_LENGTH) );
if (i > 0)
printf("-------------------------------------------------------------------------------\n\n");
printf("%s: %s\n", _i18n_msg_get(ls_catd,NL_SETN,1210,
"QUEUE"), qp->queue); /* catgets 1210 */
printf(" -- %s", qp->description);
if (qp->qAttrib & Q_ATTRIB_DEFAULT) {
if (numDefaults == 1)
printf(" %s.\n\n", _i18n_msg_get(ls_catd,NL_SETN,1211,
"This is the default queue")); /* catgets 1211 */
else
printf(" %s.\n\n", _i18n_msg_get(ls_catd,NL_SETN,1212,
"This is one of the default queues")); /* catgets 1212 */
} else
printf("\n\n");
printf((_i18n_msg_get(ls_catd,NL_SETN,1213, "PARAMETERS/STATISTICS\n"))); /* catgets 1213 */
prtWord(QUEUE_PRIO_LENGTH, I18N_PRIO, 0);
if ( lsbMode_ & LSB_MODE_BATCH )
prtWord(QUEUE_NICE_LENGTH, I18N_NICE, 1);
prtWord(QUEUE_STATUS_LENGTH, I18N_STATUS, 0);
if ( lsbMode_ & LSB_MODE_BATCH ) {
prtWord(QUEUE_MAX_LENGTH, I18N_MAX, -1);
prtWord(QUEUE_JL_U_LENGTH, I18N_JL_U, -1);
prtWord(QUEUE_JL_P_LENGTH, I18N_JL_P, -1);
prtWord(QUEUE_JL_H_LENGTH, I18N_JL_H, -1);
};
prtWord(QUEUE_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(QUEUE_PEND_LENGTH, I18N_PEND, -1);
prtWord(QUEUE_RUN_LENGTH, I18N_RUN, -1);
prtWord(QUEUE_SSUSP_LENGTH, I18N_SSUSP, -1);
prtWord(QUEUE_USUSP_LENGTH, I18N_USUSP, -1);
prtWord(QUEUE_RSV_LENGTH, I18N_RSV, -1);
printf("\n");
prtWordL(QUEUE_PRIO_LENGTH,
prtValue(QUEUE_PRIO_LENGTH-1, qp->priority));
if ( lsbMode_ & LSB_MODE_BATCH )
prtWordL(QUEUE_NICE_LENGTH,
prtValue(QUEUE_NICE_LENGTH-1, qp->nice));
prtWord(QUEUE_STATUS_LENGTH, statusStr, 0);
if ( lsbMode_ & LSB_MODE_BATCH ) {
sprintf(fomt, "%%%ds%%%ds%%%ds%%%ds", QUEUE_MAX_LENGTH,
QUEUE_JL_U_LENGTH,
QUEUE_JL_P_LENGTH,
QUEUE_JL_H_LENGTH );
printf(fomt,
maxJobs, userJobLimit, procJobLimit, hostJobLimit);
};
sprintf(fomt, "%%%dd %%%dd %%%dd %%%dd %%%dd %%%dd\n",
QUEUE_NJOBS_LENGTH,
QUEUE_PEND_LENGTH,
QUEUE_RUN_LENGTH,
QUEUE_SSUSP_LENGTH,
QUEUE_USUSP_LENGTH,
QUEUE_RSV_LENGTH );
printf(fomt,
qp->numJobs, qp->numPEND, qp->numRUN,
qp->numSSUSP, qp->numUSUSP, qp->numRESERVE);
if ( qp->mig < INFINIT_INT )
printf((_i18n_msg_get(ls_catd,NL_SETN,1215,
"Migration threshold is %d minutes\n")), qp->mig); /* catgets 1215 */
if ( qp->schedDelay < INFINIT_INT )
printf((_i18n_msg_get(ls_catd,NL_SETN,1216, "Schedule delay for a new job is %d seconds\n")), /* catgets 1216 */
qp->schedDelay);
if ( qp->acceptIntvl < INFINIT_INT )
printf((_i18n_msg_get(ls_catd,NL_SETN,1217, "Interval for a host to accept two jobs is %d seconds\n")), /* catgets 1217 */
qp->acceptIntvl);
if (((qp->defLimits[LSF_RLIMIT_CPU] != INFINIT_INT) &&
(qp->defLimits[LSF_RLIMIT_CPU] > 0 )) ||
((qp->defLimits[LSF_RLIMIT_RUN] != INFINIT_INT) &&
(qp->defLimits[LSF_RLIMIT_RUN] > 0 )) ||
((qp->defLimits[LSF_RLIMIT_DATA] != INFINIT_INT) &&
(qp->defLimits[LSF_RLIMIT_DATA] > 0 )) ||
((qp->defLimits[LSF_RLIMIT_RSS] != INFINIT_INT) &&
(qp->defLimits[LSF_RLIMIT_RSS] > 0 )) ||
((qp->defLimits[LSF_RLIMIT_PROCESS] != INFINIT_INT) &&
(qp->defLimits[LSF_RLIMIT_PROCESS] > 0 ))) {
printf("\n");
printf(_i18n_msg_get(ls_catd,NL_SETN,1270,
"DEFAULT LIMITS:") /* catgets 1270 */ );
prtResourceLimit (qp->defLimits, qp->hostSpec, 1.0, 0);
printf("\n");
printf(_i18n_msg_get(ls_catd,NL_SETN,1271,
"MAXIMUM LIMITS:") /* catgets 1271 */ );
}
procLimits[0] = qp->minProcLimit;
procLimits[1] = qp->defProcLimit;
procLimits[2] = qp->procLimit;
prtResourceLimit (qp->rLimits, qp->hostSpec, 1.0, procLimits);
if ( lsbMode_ & LSB_MODE_BATCH ) {
printf((_i18n_msg_get(ls_catd,NL_SETN,1218, "\nSCHEDULING PARAMETERS\n"))); /* catgets 1218 */
if (printThresholds (qp->loadSched, qp->loadStop, NULL, NULL,
MIN(lsInfo->numIndx, qp->nIdx), lsInfo) < 0)
exit (-1);
}
if ((qp->qAttrib & Q_ATTRIB_EXCLUSIVE)
|| (qp->qAttrib & Q_ATTRIB_BACKFILL)
|| (qp->qAttrib & Q_ATTRIB_IGNORE_DEADLINE)
|| (qp->qAttrib & Q_ATTRIB_ONLY_INTERACTIVE)
|| (qp->qAttrib & Q_ATTRIB_NO_INTERACTIVE)) {
printf("\n%s:", _i18n_msg_get(ls_catd,NL_SETN,1219,
"SCHEDULING POLICIES")); /* catgets 1219 */
if (qp->qAttrib & Q_ATTRIB_BACKFILL)
printf(" %s", (_i18n_msg_get(ls_catd,NL_SETN,1223,
"BACKFILL"))); /* catgets 1223 */
if (qp->qAttrib & Q_ATTRIB_IGNORE_DEADLINE)
printf(" %s", (_i18n_msg_get(ls_catd,NL_SETN,1224,
"IGNORE_DEADLINE"))); /* catgets 1224 */
if (qp->qAttrib & Q_ATTRIB_EXCLUSIVE)
printf(" %s", (_i18n_msg_get(ls_catd,NL_SETN,1225,
"EXCLUSIVE"))); /* catgets 1225 */
if (qp->qAttrib & Q_ATTRIB_NO_INTERACTIVE)
printf(" %s", (_i18n_msg_get(ls_catd,NL_SETN,1226,
"NO_INTERACTIVE"))); /* catgets 1226 */
if (qp->qAttrib & Q_ATTRIB_ONLY_INTERACTIVE)
printf(" %s", (_i18n_msg_get(ls_catd,NL_SETN,1227,
"ONLY_INTERACTIVE"))); /* catgets 1227 */
printf("\n");
}
if (strcmp (qp->defaultHostSpec, " ") != 0)
printf("\n%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1230, "DEFAULT HOST SPECIFICATION")), qp->defaultHostSpec); /* catgets 1230 */
if (qp->windows && strcmp (qp->windows, " " ) !=0)
printf("\n%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1231, "RUN_WINDOW")), qp->windows); /* catgets 1231 */
if (strcmp (qp->windowsD, " ") != 0)
printf("\n%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1232, "DISPATCH_WINDOW")), qp->windowsD); /* catgets 1232 */
if (lsbMode_ & LSB_MODE_BATCH) {
if ( strcmp(qp->userList, " ") == 0) {
printf("\n%s: %s\n", I18N_USERS,
I18N(408, "all users")); /* catgets 408 */
} else {
if (strcmp(qp->userList, " ") != 0 && qp->userList[0] != 0)
printf("\n%s: %s\n", I18N_USERS, qp->userList);
}
}
if (strcmp(qp->hostList, " ") == 0) {
if (lsbMode_ & LSB_MODE_BATCH)
printf("%s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1235, "HOSTS: all hosts used by the LSF Batch system"))); /* catgets 1235 */
else
printf("%s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1236, "HOSTS: all hosts used by the LSF JobScheduler system"))); /* catgets 1236 */
} else {
if (strcmp(qp->hostList, " ") != 0 && qp->hostList[0])
printf("%s: %s\n", I18N_HOSTS, qp->hostList);
}
if (strcmp (qp->prepostUsername, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1238, "PRE_POST_EXEC_USER")), qp->prepostUsername); /* catgets 1238 */
if (strcmp (qp->admins, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1239, "ADMINISTRATORS")), qp->admins); /* catgets 1239 */
if (strcmp (qp->preCmd, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1240, "PRE_EXEC")), qp->preCmd); /* catgets 1240 */
if (strcmp (qp->postCmd, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1241, "POST_EXEC")), qp->postCmd); /* catgets 1241 */
if (strcmp (qp->requeueEValues, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1242, "REQUEUE_EXIT_VALUES")), qp->requeueEValues); /* catgets 1242 */
if (strcmp (qp->resReq, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1243, "RES_REQ")), qp->resReq); /* catgets 1243 */
if (qp->slotHoldTime > 0)
printf((_i18n_msg_get(ls_catd,NL_SETN,1244, "Maximum slot reservation time: %d seconds\n")), qp->slotHoldTime); /* catgets 1244 */
if (strcmp (qp->resumeCond, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1245, "RESUME_COND")), qp->resumeCond); /* catgets 1245 */
if (strcmp (qp->stopCond, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1246, "STOP_COND")), qp->stopCond); /* catgets 1246 */
if (strcmp (qp->jobStarter, " ") != 0)
printf("%s: %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1247, "JOB_STARTER")), qp->jobStarter); /* catgets 1247 */
if (qp->qAttrib & Q_ATTRIB_RERUNNABLE)
printf("RERUNNABLE : yes\n");
if ( qp->qAttrib & Q_ATTRIB_CHKPNT ) {
printf((_i18n_msg_get(ls_catd,NL_SETN,1261, "CHKPNTDIR : %s\n")), qp->chkpntDir); /* catgets 1261 */
printf((_i18n_msg_get(ls_catd,NL_SETN,1262, "CHKPNTPERIOD : %d\n")), qp->chkpntPeriod); /* catgets 1262 */
}
if (qp->qAttrib & Q_ATTRIB_ROUND_ROBIN)
printf("ROUN_ROBIN_SCHEDULING: yes\n");
printf("\n");
printFlag = 0;
if ((qp->suspendActCmd != NULL)
&& (qp->suspendActCmd[0] != ' '))
printFlag = 1;
printFlag1 = 0;
if ((qp->resumeActCmd != NULL)
&& (qp->resumeActCmd[0] != ' '))
printFlag1 = 1;
printFlag2 = 0;
if ((qp->terminateActCmd != NULL)
&& (qp->terminateActCmd[0] != ' '))
printFlag2 = 1;
if (printFlag || printFlag1 || printFlag2)
printf("%s:\n",
(_i18n_msg_get(ls_catd,NL_SETN,1251, "JOB_CONTROLS"))); /* catgets 1251 */
if (printFlag) {
printf(" %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1252, "SUSPEND:"))); /* catgets 1252 */
if (strcmp (qp->suspendActCmd, " ") != 0)
printf(" [%s]\n", qp->suspendActCmd);
}
if (printFlag1) {
printf(" %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1253, "RESUME:"))); /* catgets 1253 */
if (strcmp (qp->resumeActCmd, " ") != 0)
printf(" [%s]\n", qp->resumeActCmd);
}
if (printFlag2) {
printf(" %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1254, "TERMINATE:"))); /* catgets 1254 */
if (strcmp (qp->terminateActCmd, " ") != 0)
printf(" [%s]\n", qp->terminateActCmd);
}
if (printFlag || printFlag1 || printFlag2)
printf("\n");
printFlag = terminateWhen_(qp->sigMap, "USER");
printFlag1 = terminateWhen_(qp->sigMap, "WINDOW");
printFlag2 = terminateWhen_(qp->sigMap, "LOAD");
if (printFlag | printFlag1 | printFlag2) {
printf((_i18n_msg_get(ls_catd,NL_SETN,1255, "TERMINATE_WHEN = "))); /* catgets 1255 */
if (printFlag) printf((_i18n_msg_get(ls_catd,NL_SETN,1256, "USER "))); /* catgets 1256 */
if (printFlag1) printf((_i18n_msg_get(ls_catd,NL_SETN,1258, "WINDOW "))); /* catgets 1258 */
if (printFlag2) printf((_i18n_msg_get(ls_catd,NL_SETN,1259, "LOAD"))); /* catgets 1259 */
printf("\n");
}
}
printf("\n");
}