747 строки
24 KiB
C
747 строки
24 KiB
C
/*
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
|
* University Research and Technology
|
|
* Corporation. All rights reserved.
|
|
* Copyright (c) 2004-2006 The University of Tennessee and The University
|
|
* of Tennessee Research Foundation. All rights
|
|
* reserved.
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
* University of Stuttgart. All rights reserved.
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
* All rights reserved.
|
|
* Copyright (c) 2008-2011 Cisco Systems, Inc. All rights reserved.
|
|
* Copyright (c) 2012-2013 Los Alamos National Security, LLC.
|
|
* All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*/
|
|
#include "orte_config.h"
|
|
#include "orte/types.h"
|
|
#include "orte/constants.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include "opal/util/show_help.h"
|
|
#include "opal/util/output.h"
|
|
#include "opal/dss/dss.h"
|
|
#include "opal/mca/event/event.h"
|
|
|
|
#include "orte/mca/errmgr/errmgr.h"
|
|
#include "orte/mca/rml/rml.h"
|
|
#include "orte/mca/rml/rml_types.h"
|
|
#include "orte/mca/routed/routed.h"
|
|
#include "orte/util/name_fns.h"
|
|
#include "orte/util/proc_info.h"
|
|
#include "orte/runtime/orte_globals.h"
|
|
|
|
#include "orte/util/show_help.h"
|
|
|
|
bool orte_help_want_aggregate = false;
|
|
|
|
/*
|
|
* Local variable to know whether aggregated show_help is available or
|
|
* not
|
|
*/
|
|
static bool ready = false;
|
|
|
|
/*
|
|
* Same for systems with or without full ORTE support
|
|
*/
|
|
bool orte_show_help_is_available(void)
|
|
{
|
|
/* This is a function only to give us forward flexibility in case
|
|
we need a more complicated check someday. */
|
|
|
|
return ready;
|
|
}
|
|
|
|
/* List items for holding (filename, topic) tuples */
|
|
typedef struct {
|
|
opal_list_item_t super;
|
|
/* The filename */
|
|
char *tli_filename;
|
|
/* The topic */
|
|
char *tli_topic;
|
|
/* List of process names that have displayed this (filename, topic) */
|
|
opal_list_t tli_processes;
|
|
/* Time this message was displayed */
|
|
time_t tli_time_displayed;
|
|
/* Count of processes since last display (i.e., "new" processes
|
|
that have showed this message that have not yet been output) */
|
|
int tli_count_since_last_display;
|
|
/* Do we want to display these? */
|
|
bool tli_display;
|
|
} tuple_list_item_t;
|
|
|
|
static void tuple_list_item_constructor(tuple_list_item_t *obj);
|
|
static void tuple_list_item_destructor(tuple_list_item_t *obj);
|
|
OBJ_CLASS_INSTANCE(tuple_list_item_t, opal_list_item_t,
|
|
tuple_list_item_constructor,
|
|
tuple_list_item_destructor);
|
|
|
|
|
|
/* List of (filename, topic) tuples that have already been displayed */
|
|
static opal_list_t abd_tuples;
|
|
|
|
/* How long to wait between displaying duplicate show_help notices */
|
|
static struct timeval show_help_interval = { 5, 0 };
|
|
|
|
/* Timer for displaying duplicate help message notices */
|
|
static time_t show_help_time_last_displayed = 0;
|
|
static bool show_help_timer_set = false;
|
|
static opal_event_t show_help_timer_event;
|
|
|
|
static opal_show_help_fn_t save_help = NULL;
|
|
|
|
static void tuple_list_item_constructor(tuple_list_item_t *obj)
|
|
{
|
|
obj->tli_filename = NULL;
|
|
obj->tli_topic = NULL;
|
|
OBJ_CONSTRUCT(&(obj->tli_processes), opal_list_t);
|
|
obj->tli_time_displayed = time(NULL);
|
|
obj->tli_count_since_last_display = 0;
|
|
obj->tli_display = true;
|
|
}
|
|
|
|
static void tuple_list_item_destructor(tuple_list_item_t *obj)
|
|
{
|
|
opal_list_item_t *item, *next;
|
|
|
|
if (NULL != obj->tli_filename) {
|
|
free(obj->tli_filename);
|
|
}
|
|
if (NULL != obj->tli_topic) {
|
|
free(obj->tli_topic);
|
|
}
|
|
for (item = opal_list_get_first(&(obj->tli_processes));
|
|
opal_list_get_end(&(obj->tli_processes)) != item;
|
|
item = next) {
|
|
next = opal_list_get_next(item);
|
|
opal_list_remove_item(&(obj->tli_processes), item);
|
|
OBJ_RELEASE(item);
|
|
}
|
|
}
|
|
|
|
/* dealing with special characters in xml output */
|
|
static char* xml_format(unsigned char *input)
|
|
{
|
|
int i, j, k, len, outlen;
|
|
char *output, qprint[10];
|
|
char *endtag="</stderr>";
|
|
char *starttag="<stderr>";
|
|
int endtaglen, starttaglen;
|
|
bool endtagged = false;
|
|
|
|
len = strlen((char*)input);
|
|
/* add some arbitrary size padding */
|
|
output = (char*)malloc((len+1024)*sizeof(char));
|
|
if (NULL == output) {
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
|
return (char*)input; /* default to no xml formatting */
|
|
}
|
|
memset(output, 0, len+1024);
|
|
outlen = len+1023;
|
|
endtaglen = strlen(endtag);
|
|
starttaglen = strlen(starttag);
|
|
|
|
/* start at the beginning */
|
|
k=0;
|
|
|
|
/* start with the tag */
|
|
for (j=0; j < starttaglen && k < outlen; j++) {
|
|
output[k++] = starttag[j];
|
|
}
|
|
|
|
for (i=0; i < len; i++) {
|
|
if ('&' == input[i]) {
|
|
if (k+5 >= outlen) {
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
|
goto error;
|
|
}
|
|
snprintf(qprint, 10, "&");
|
|
for (j=0; j < (int)strlen(qprint) && k < outlen; j++) {
|
|
output[k++] = qprint[j];
|
|
}
|
|
} else if ('<' == input[i]) {
|
|
if (k+4 >= outlen) {
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
|
goto error;
|
|
}
|
|
snprintf(qprint, 10, "<");
|
|
for (j=0; j < (int)strlen(qprint) && k < outlen; j++) {
|
|
output[k++] = qprint[j];
|
|
}
|
|
} else if ('>' == input[i]) {
|
|
if (k+4 >= outlen) {
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
|
goto error;
|
|
}
|
|
snprintf(qprint, 10, ">");
|
|
for (j=0; j < (int)strlen(qprint) && k < outlen; j++) {
|
|
output[k++] = qprint[j];
|
|
}
|
|
} else if (input[i] < 32 || input[i] > 127) {
|
|
/* this is a non-printable character, so escape it too */
|
|
if (k+7 >= outlen) {
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
|
goto error;
|
|
}
|
|
snprintf(qprint, 10, "&#%03d;", (int)input[i]);
|
|
for (j=0; j < (int)strlen(qprint) && k < outlen; j++) {
|
|
output[k++] = qprint[j];
|
|
}
|
|
/* if this was a \n, then we also need to break the line with the end tag */
|
|
if ('\n' == input[i] && (k+endtaglen+1) < outlen) {
|
|
/* we need to break the line with the end tag */
|
|
for (j=0; j < endtaglen && k < outlen-1; j++) {
|
|
output[k++] = endtag[j];
|
|
}
|
|
/* move the <cr> over */
|
|
output[k++] = '\n';
|
|
/* if this isn't the end of the input buffer, add a new start tag */
|
|
if (i < len-1 && (k+starttaglen) < outlen) {
|
|
for (j=0; j < starttaglen && k < outlen; j++) {
|
|
output[k++] = starttag[j];
|
|
endtagged = false;
|
|
}
|
|
} else {
|
|
endtagged = true;
|
|
}
|
|
}
|
|
} else {
|
|
output[k++] = input[i];
|
|
}
|
|
}
|
|
|
|
if (!endtagged) {
|
|
/* need to add an endtag */
|
|
for (j=0; j < endtaglen && k < outlen-1; j++) {
|
|
output[k++] = endtag[j];
|
|
}
|
|
output[k++] = '\n';
|
|
}
|
|
|
|
return output;
|
|
|
|
error:
|
|
/* if we couldn't complete the processing for
|
|
* some reason, return the unprocessed input
|
|
* so at least the message gets out!
|
|
*/
|
|
free(output);
|
|
return (char*)input;
|
|
}
|
|
|
|
|
|
/*
|
|
* Returns ORTE_SUCCESS if the strings match; ORTE_ERROR otherwise.
|
|
*/
|
|
static int match(const char *a, const char *b)
|
|
{
|
|
int rc = ORTE_ERROR;
|
|
char *p1, *p2, *tmp1 = NULL, *tmp2 = NULL;
|
|
size_t min;
|
|
|
|
/* Check straight string match first */
|
|
if (0 == strcmp(a, b)) return ORTE_SUCCESS;
|
|
|
|
if (NULL != strchr(a, '*') || NULL != strchr(b, '*')) {
|
|
tmp1 = strdup(a);
|
|
if (NULL == tmp1) {
|
|
return ORTE_ERR_OUT_OF_RESOURCE;
|
|
}
|
|
tmp2 = strdup(b);
|
|
if (NULL == tmp2) {
|
|
free(tmp1);
|
|
return ORTE_ERR_OUT_OF_RESOURCE;
|
|
}
|
|
p1 = strchr(tmp1, '*');
|
|
p2 = strchr(tmp2, '*');
|
|
|
|
if (NULL != p1) {
|
|
*p1 = '\0';
|
|
}
|
|
if (NULL != p2) {
|
|
*p2 = '\0';
|
|
}
|
|
min = strlen(tmp1);
|
|
if (strlen(tmp2) < min) {
|
|
min = strlen(tmp2);
|
|
}
|
|
if (0 == min || 0 == strncmp(tmp1, tmp2, min)) {
|
|
rc = ORTE_SUCCESS;
|
|
}
|
|
free(tmp1);
|
|
free(tmp2);
|
|
return rc;
|
|
}
|
|
|
|
/* No match */
|
|
return ORTE_ERROR;
|
|
}
|
|
|
|
/*
|
|
* Check to see if a given (filename, topic) tuple has been displayed
|
|
* already. Return ORTE_SUCCESS if so, or ORTE_ERR_NOT_FOUND if not.
|
|
*
|
|
* Always return a tuple_list_item_t representing this (filename,
|
|
* topic) entry in the list of "already been displayed tuples" (if it
|
|
* wasn't in the list already, this function will create a new entry
|
|
* in the list and return it).
|
|
*
|
|
* Note that a list is not an overly-efficient mechanism for this kind
|
|
* of data. The assupmtion is that there will only be a small numebr
|
|
* of (filename, topic) tuples displayed so the storage required will
|
|
* be fairly small, and linear searches will be fast enough.
|
|
*/
|
|
static int get_tli(const char *filename, const char *topic,
|
|
tuple_list_item_t **tli)
|
|
{
|
|
opal_list_item_t *item;
|
|
|
|
/* Search the list for a duplicate. */
|
|
for (item = opal_list_get_first(&abd_tuples);
|
|
opal_list_get_end(&abd_tuples) != item;
|
|
item = opal_list_get_next(item)) {
|
|
(*tli) = (tuple_list_item_t*) item;
|
|
if (ORTE_SUCCESS == match((*tli)->tli_filename, filename) &&
|
|
ORTE_SUCCESS == match((*tli)->tli_topic, topic)) {
|
|
return ORTE_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/* Nope, we didn't find it -- make a new one */
|
|
*tli = OBJ_NEW(tuple_list_item_t);
|
|
if (NULL == *tli) {
|
|
return ORTE_ERR_OUT_OF_RESOURCE;
|
|
}
|
|
(*tli)->tli_filename = strdup(filename);
|
|
(*tli)->tli_topic = strdup(topic);
|
|
opal_list_append(&abd_tuples, &((*tli)->super));
|
|
return ORTE_ERR_NOT_FOUND;
|
|
}
|
|
|
|
|
|
static void show_accumulated_duplicates(int fd, short event, void *context)
|
|
{
|
|
opal_list_item_t *item;
|
|
time_t now = time(NULL);
|
|
tuple_list_item_t *tli;
|
|
char *tmp, *output;
|
|
|
|
/* Loop through all the messages we've displayed and see if any
|
|
processes have sent duplicates that have not yet been displayed
|
|
yet */
|
|
for (item = opal_list_get_first(&abd_tuples);
|
|
opal_list_get_end(&abd_tuples) != item;
|
|
item = opal_list_get_next(item)) {
|
|
tli = (tuple_list_item_t*) item;
|
|
if (tli->tli_display &&
|
|
tli->tli_count_since_last_display > 0) {
|
|
static bool first = true;
|
|
if (orte_xml_output) {
|
|
asprintf(&tmp, "%d more process%s sent help message %s / %s",
|
|
tli->tli_count_since_last_display,
|
|
(tli->tli_count_since_last_display > 1) ? "es have" : " has",
|
|
tli->tli_filename, tli->tli_topic);
|
|
output = xml_format((unsigned char*)tmp);
|
|
free(tmp);
|
|
fprintf(orte_xml_fp, "%s", output);
|
|
free(output);
|
|
} else {
|
|
opal_output(0, "%d more process%s sent help message %s / %s",
|
|
tli->tli_count_since_last_display,
|
|
(tli->tli_count_since_last_display > 1) ? "es have" : " has",
|
|
tli->tli_filename, tli->tli_topic);
|
|
}
|
|
tli->tli_count_since_last_display = 0;
|
|
|
|
if (first) {
|
|
if (orte_xml_output) {
|
|
fprintf(orte_xml_fp, "<stderr>Set MCA parameter \"orte_base_help_aggregate\" to 0 to see all help / error messages</stderr>\n");
|
|
fflush(orte_xml_fp);
|
|
} else {
|
|
opal_output(0, "Set MCA parameter \"orte_base_help_aggregate\" to 0 to see all help / error messages");
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
show_help_time_last_displayed = now;
|
|
show_help_timer_set = false;
|
|
}
|
|
|
|
static int show_help(const char *filename, const char *topic,
|
|
const char *output, orte_process_name_t *sender)
|
|
{
|
|
int rc;
|
|
tuple_list_item_t *tli = NULL;
|
|
orte_namelist_t *pnli;
|
|
time_t now = time(NULL);
|
|
|
|
/* If we're aggregating, check for duplicates. Otherwise, don't
|
|
track duplicates at all and always display the message. */
|
|
if (orte_help_want_aggregate) {
|
|
rc = get_tli(filename, topic, &tli);
|
|
} else {
|
|
rc = ORTE_ERR_NOT_FOUND;
|
|
}
|
|
|
|
/* If there's no output string (i.e., this is a control message
|
|
asking us to suppress), then skip to the end. */
|
|
if (NULL == output) {
|
|
tli->tli_display = false;
|
|
goto after_output;
|
|
}
|
|
|
|
/* Was it already displayed? */
|
|
if (ORTE_SUCCESS == rc) {
|
|
/* Yes. But do we want to print anything? That's complicated.
|
|
|
|
We always show the first message of a given (filename,
|
|
topic) tuple as soon as it arrives. But we don't want to
|
|
show duplicate notices often, because we could get overrun
|
|
with them. So we want to gather them up and say "We got N
|
|
duplicates" every once in a while.
|
|
|
|
And keep in mind that at termination, we'll unconditionally
|
|
show all accumulated duplicate notices.
|
|
|
|
A simple scheme is as follows:
|
|
- when the first of a (filename, topic) tuple arrives
|
|
- print the message
|
|
- if a timer is not set, set T=now
|
|
- when a duplicate (filename, topic) tuple arrives
|
|
- if now>(T+5) and timer is not set (due to
|
|
non-pre-emptiveness of our libevent, a timer *could* be
|
|
set!)
|
|
- print all accumulated duplicates
|
|
- reset T=now
|
|
- else if a timer was not set, set the timer for T+5
|
|
- else if a timer was set, do nothing (just wait)
|
|
- set T=now when the timer expires
|
|
*/
|
|
++tli->tli_count_since_last_display;
|
|
if (now > show_help_time_last_displayed + 5 && !show_help_timer_set) {
|
|
show_accumulated_duplicates(0, 0, NULL);
|
|
} else if (!show_help_timer_set) {
|
|
opal_event_evtimer_set(orte_event_base, &show_help_timer_event,
|
|
show_accumulated_duplicates, NULL);
|
|
opal_event_evtimer_add(&show_help_timer_event, &show_help_interval);
|
|
show_help_timer_set = true;
|
|
}
|
|
}
|
|
/* Not already displayed */
|
|
else if (ORTE_ERR_NOT_FOUND == rc) {
|
|
if (orte_xml_output) {
|
|
char *tmp;
|
|
tmp = xml_format((unsigned char*)output);
|
|
fprintf(orte_xml_fp, "%s", tmp);
|
|
fflush(orte_xml_fp);
|
|
free(tmp);
|
|
} else {
|
|
opal_output(orte_clean_output, "%s", output);
|
|
}
|
|
if (!show_help_timer_set) {
|
|
show_help_time_last_displayed = now;
|
|
}
|
|
}
|
|
/* Some other error occurred */
|
|
else {
|
|
ORTE_ERROR_LOG(rc);
|
|
return rc;
|
|
}
|
|
|
|
after_output:
|
|
/* If we're aggregating, add this process name to the list */
|
|
if (orte_help_want_aggregate) {
|
|
pnli = OBJ_NEW(orte_namelist_t);
|
|
if (NULL == pnli) {
|
|
rc = ORTE_ERR_OUT_OF_RESOURCE;
|
|
ORTE_ERROR_LOG(rc);
|
|
return rc;
|
|
}
|
|
pnli->name = *sender;
|
|
opal_list_append(&(tli->tli_processes), &(pnli->super));
|
|
}
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Note that this function is called from ess/hnp, so don't make it
|
|
static */
|
|
void orte_show_help_recv(int status, orte_process_name_t* sender,
|
|
opal_buffer_t *buffer, orte_rml_tag_t tag,
|
|
void* cbdata)
|
|
{
|
|
char *output=NULL;
|
|
char *filename=NULL, *topic=NULL;
|
|
int32_t n;
|
|
int8_t have_output;
|
|
int rc;
|
|
|
|
OPAL_OUTPUT_VERBOSE((5, orte_debug_output,
|
|
"%s got show_help from %s",
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
ORTE_NAME_PRINT(sender)));
|
|
|
|
/* unpack the filename of the show_help text file */
|
|
n = 1;
|
|
if (ORTE_SUCCESS != (rc = opal_dss.unpack(buffer, &filename, &n, OPAL_STRING))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
goto cleanup;
|
|
}
|
|
/* unpack the topic tag */
|
|
n = 1;
|
|
if (ORTE_SUCCESS != (rc = opal_dss.unpack(buffer, &topic, &n, OPAL_STRING))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
goto cleanup;
|
|
}
|
|
/* unpack the flag */
|
|
n = 1;
|
|
if (ORTE_SUCCESS != (rc = opal_dss.unpack(buffer, &have_output, &n, OPAL_INT8))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
goto cleanup;
|
|
}
|
|
|
|
/* If we have an output string, unpack it */
|
|
if (have_output) {
|
|
n = 1;
|
|
if (ORTE_SUCCESS != (rc = opal_dss.unpack(buffer, &output, &n, OPAL_STRING))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
/* Send it to show_help */
|
|
rc = show_help(filename, topic, output, sender);
|
|
|
|
cleanup:
|
|
if (NULL != output) {
|
|
free(output);
|
|
}
|
|
if (NULL != filename) {
|
|
free(filename);
|
|
}
|
|
if (NULL != topic) {
|
|
free(topic);
|
|
}
|
|
}
|
|
|
|
int orte_show_help_init(void)
|
|
{
|
|
OPAL_OUTPUT_VERBOSE((5, orte_debug_output, "orte_show_help init"));
|
|
|
|
/* Show help duplicate detection */
|
|
if (ready) {
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
OBJ_CONSTRUCT(&abd_tuples, opal_list_t);
|
|
|
|
save_help = opal_show_help;
|
|
opal_show_help = orte_show_help;
|
|
ready = true;
|
|
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
void orte_show_help_finalize(void)
|
|
{
|
|
if (!ready) {
|
|
return;
|
|
}
|
|
ready = false;
|
|
|
|
opal_show_help = save_help;
|
|
save_help = NULL;
|
|
|
|
/* Shutdown show_help, showing final messages */
|
|
if (ORTE_PROC_IS_HNP) {
|
|
show_accumulated_duplicates(0, 0, NULL);
|
|
OBJ_DESTRUCT(&abd_tuples);
|
|
if (show_help_timer_set) {
|
|
opal_event_evtimer_del(&show_help_timer_event);
|
|
}
|
|
|
|
/* cancel the recv */
|
|
orte_rml.recv_cancel(ORTE_NAME_WILDCARD, ORTE_RML_TAG_SHOW_HELP);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int orte_show_help(const char *filename, const char *topic,
|
|
bool want_error_header, ...)
|
|
{
|
|
int rc = ORTE_SUCCESS;
|
|
va_list arglist;
|
|
char *output;
|
|
|
|
if (orte_execute_quiet) {
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
va_start(arglist, want_error_header);
|
|
output = opal_show_help_vstring(filename, topic, want_error_header,
|
|
arglist);
|
|
va_end(arglist);
|
|
|
|
/* If nothing came back, there's nothing to do */
|
|
if (NULL == output) {
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
rc = orte_show_help_norender(filename, topic, want_error_header, output);
|
|
free(output);
|
|
return rc;
|
|
}
|
|
|
|
int orte_show_help_norender(const char *filename, const char *topic,
|
|
bool want_error_header, const char *output)
|
|
{
|
|
int rc = ORTE_SUCCESS;
|
|
int8_t have_output = 1;
|
|
|
|
if (!ready) {
|
|
/* if we are finalizing, then we have no way to process
|
|
* this through the orte_show_help system - just drop it to
|
|
* stderr; that's at least better than not showing it.
|
|
*
|
|
* If we are not finalizing, then this is probably a show_help
|
|
* stemming from either a cmd-line request to display the usage
|
|
* message, or a show_help related to a user error. In either case,
|
|
* we can't do anything but just print to stderr.
|
|
*/
|
|
fprintf(stderr, "%s", output);
|
|
goto CLEANUP;
|
|
}
|
|
|
|
/* if we are the HNP, or the RML has not yet been setup,
|
|
* or ROUTED has not been setup,
|
|
* or we weren't given an HNP, or we are running in standalone
|
|
* mode, then all we can do is process this locally
|
|
*/
|
|
if (ORTE_PROC_IS_HNP || ORTE_PROC_IS_TOOL ||
|
|
orte_standalone_operation ||
|
|
NULL == orte_rml.send_buffer_nb ||
|
|
NULL == orte_routed.get_route ||
|
|
NULL == orte_process_info.my_hnp_uri) {
|
|
rc = show_help(filename, topic, output, ORTE_PROC_MY_NAME);
|
|
}
|
|
|
|
/* otherwise, we relay the output message to
|
|
* the HNP for processing
|
|
*/
|
|
else {
|
|
opal_buffer_t *buf;
|
|
static bool am_inside = false;
|
|
|
|
/* JMS Note that we *may* have a recursion situation here where
|
|
the RML could call show_help. Need to think about this
|
|
properly, but put a safeguard in here for sure for the time
|
|
being. */
|
|
if (am_inside) {
|
|
rc = show_help(filename, topic, output, ORTE_PROC_MY_NAME);
|
|
} else {
|
|
am_inside = true;
|
|
|
|
/* build the message to the HNP */
|
|
buf = OBJ_NEW(opal_buffer_t);
|
|
/* pack the filename of the show_help text file */
|
|
opal_dss.pack(buf, &filename, 1, OPAL_STRING);
|
|
/* pack the topic tag */
|
|
opal_dss.pack(buf, &topic, 1, OPAL_STRING);
|
|
/* pack the flag that we have a string */
|
|
opal_dss.pack(buf, &have_output, 1, OPAL_INT8);
|
|
/* pack the resulting string */
|
|
opal_dss.pack(buf, &output, 1, OPAL_STRING);
|
|
/* send it to the HNP */
|
|
if (ORTE_SUCCESS != (rc = orte_rml.send_buffer_nb(ORTE_PROC_MY_HNP, buf,
|
|
ORTE_RML_TAG_SHOW_HELP,
|
|
orte_rml_send_callback, NULL))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
OBJ_RELEASE(buf);
|
|
/* okay, that didn't work, just process locally error, just ignore return */
|
|
show_help(filename, topic, NULL, ORTE_PROC_MY_NAME);
|
|
} else {
|
|
rc = ORTE_SUCCESS;
|
|
}
|
|
am_inside = false;
|
|
}
|
|
}
|
|
|
|
CLEANUP:
|
|
return rc;
|
|
}
|
|
|
|
int orte_show_help_suppress(const char *filename, const char *topic)
|
|
{
|
|
int rc = ORTE_SUCCESS;
|
|
int8_t have_output = 0;
|
|
|
|
if (orte_execute_quiet) {
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
if (!ready) {
|
|
/* If we are finalizing, then we have no way to process this
|
|
through the orte_show_help system - just drop it. */
|
|
return ORTE_SUCCESS;
|
|
}
|
|
|
|
/* If we are the HNP, or the RML has not yet been setup, or ROUTED
|
|
has not been setup, or we weren't given an HNP, then all we can
|
|
do is process this locally. */
|
|
if (ORTE_PROC_IS_HNP ||
|
|
NULL == orte_rml.send_buffer_nb ||
|
|
NULL == orte_routed.get_route ||
|
|
NULL == orte_process_info.my_hnp_uri) {
|
|
rc = show_help(filename, topic, NULL, ORTE_PROC_MY_NAME);
|
|
}
|
|
|
|
/* otherwise, we relay the output message to
|
|
* the HNP for processing
|
|
*/
|
|
else {
|
|
opal_buffer_t *buf;
|
|
static bool am_inside = false;
|
|
|
|
/* JMS Note that we *may* have a recursion situation here where
|
|
the RML could call show_help. Need to think about this
|
|
properly, but put a safeguard in here for sure for the time
|
|
being. */
|
|
if (am_inside) {
|
|
rc = show_help(filename, topic, NULL, ORTE_PROC_MY_NAME);
|
|
} else {
|
|
am_inside = true;
|
|
|
|
/* build the message to the HNP */
|
|
buf = OBJ_NEW(opal_buffer_t);
|
|
/* pack the filename of the show_help text file */
|
|
opal_dss.pack(buf, &filename, 1, OPAL_STRING);
|
|
/* pack the topic tag */
|
|
opal_dss.pack(buf, &topic, 1, OPAL_STRING);
|
|
/* pack the flag that we DO NOT have a string */
|
|
opal_dss.pack(buf, &have_output, 1, OPAL_INT8);
|
|
/* send it to the HNP */
|
|
if (ORTE_SUCCESS != (rc = orte_rml.send_buffer_nb(ORTE_PROC_MY_HNP, buf,
|
|
ORTE_RML_TAG_SHOW_HELP,
|
|
orte_rml_send_callback, NULL))) {
|
|
ORTE_ERROR_LOG(rc);
|
|
OBJ_RELEASE(buf);
|
|
/* okay, that didn't work, just process locally error, just ignore return */
|
|
show_help(filename, topic, NULL, ORTE_PROC_MY_NAME);
|
|
}
|
|
am_inside = false;
|
|
}
|
|
}
|
|
|
|
return ORTE_SUCCESS;
|
|
}
|