powerman: support new setresult directive

Problem: In many cases, power operations cannot capture that an
error has occurred.  Due to how device scripts are scripted, in many
cases a user will get "Command completed successfully" regardless
if the power operation was a success or not.

Solution: Support a new "setresult" statement that can inform powerman
that a power operation did not succeed.  A regex can be used to determine
what output is expected of a successful power operation.  If any are not
successful, powerman can immediately report to the user an error has occurred,
leading to a "Command completed with errors" message and exit status 1.

Some example uses:

script on_all {
	send "on\n"
	foreachnode {
		expect "([^\n:]+): ([^\n]+\n)"
		setresult $1 $2 success="^ok\n"
	}
	expect "redfishpower> "
}

script on {
	send "on %s\n"
	expect "([^\n:]+): ([^\n]+\n)"
	setresult $1 $2 success="^ok\n"
	expect "redfishpower> "
}

Fixes chaos#79

src/powerman/arglist.h

@@ -17,11 +17,16 @@
 #define PM_ARGLIST_H
 
 typedef enum { ST_UNKNOWN, ST_OFF, ST_ON } InterpState;
+/* result not required to be set after power operation,
+ * result defaults to RT_NONE in that case.
+ */
+typedef enum { RT_NONE, RT_UNKNOWN, RT_SUCCESS } InterpResult;
 
 typedef struct {
     char *node;                 /* node name (in) */
     char *val;                  /* value as returned by the device (out) */
     InterpState state;          /* interpreted value, if appropriate (out) */
+    InterpResult result;        /* interpreted result, if appropriate (out) */
 } Arg;
 
 typedef struct arglist_iterator *ArgListIterator;

src/powerman/client.c

@@ -363,6 +363,35 @@ static void _client_query_device_reply(Client * c, char *arg)
     _client_printf(c, CP_RSP_QRY_COMPLETE);
 }
 
+/*
+ * Reply to client power command (on/off/cycle/reset/beacon on/beacon off)
+ */
+static void _client_power_status_reply(Client * c, bool error)
+{
+    Arg *arg;
+    ArgListIterator itr;
+    int error_found = 0;
+
+    assert(c->cmd != NULL);
+
+    /* N.B. if result is RT_NONE, device script does not
+     * specify setresult interpretation.
+     */
+    itr = arglist_iterator_create(c->cmd->arglist);
+    while ((arg = arglist_next(itr))) {
+        if (arg->result == RT_UNKNOWN) {
+            error_found++;
+            break;
+        }
+    }
+    arglist_iterator_destroy(itr);
+
+    if (c->cmd->error || error_found)
+        _client_printf(c, CP_ERR_COM_COMPLETE);
+    else
+        _client_printf(c, CP_RSP_COM_COMPLETE);
+}
+
 /*
  * Reply to client request for plug/soft status.
  */
@@ -717,10 +746,7 @@ static void _act_finish(int client_id, ActError acterr, const char *fmt, ...)
         case PM_BEACON_OFF:        /* unflash */
         case PM_POWER_CYCLE:       /* cycle */
         case PM_RESET:             /* reset */
-            if (c->cmd->error)
-                _client_printf(c, CP_ERR_COM_COMPLETE);
-            else
-                _client_printf(c, CP_RSP_COM_COMPLETE);
+            _client_power_status_reply(c, c->cmd->error);
             break;
         default:
             assert(false);

src/powerman/device.c

@@ -78,6 +78,7 @@ typedef struct {
     ListIterator stmtitr;       /* next stmt in block */
     Stmt *cur;                  /* current stmt */
     PlugListIterator plugitr;   /* used by foreach */
+    PlugList pluglist;          /* pluglist if foreach is ranged */
     bool processing;            /* flag used by stmts, ifon/ifoff */
 } ExecCtx;
 
@@ -104,6 +105,7 @@ static bool _process_stmt(Device *dev, Action *act, ExecCtx *e,
 static bool _process_ifonoff(Device *dev, Action *act, ExecCtx *e);
 static bool _process_foreach(Device *dev, Action *act, ExecCtx *e);
 static bool _process_setplugstate(Device * dev, Action *act, ExecCtx *e);
+static bool _process_setresult(Device * dev, Action *act, ExecCtx *e);
 static bool _process_expect(Device * dev, Action *act, ExecCtx *e);
 static bool _process_send(Device * dev, Action *act, ExecCtx *e);
 static bool _process_delay(Device * dev, Action *act, ExecCtx *e,
@@ -229,6 +231,8 @@ static void _destroy_exec_ctx(ExecCtx *e)
     e->cur = NULL;
     if (e->plugs)
         list_destroy(e->plugs);
+    if (e->pluglist)
+        pluglist_destroy(e->pluglist);
     e->plugs = NULL;
     xfree(e);
 }
@@ -932,6 +936,9 @@ bool _process_stmt(Device *dev, Action *act, ExecCtx *e,
     case STMT_SETPLUGSTATE:
         finished = _process_setplugstate(dev, act, e);
         break;
+    case STMT_SETRESULT:
+        finished = _process_setresult(dev, act, e);
+        break;
     case STMT_DELAY:
         finished = _process_delay(dev, act, e, timeout);
         break;
@@ -954,8 +961,23 @@ static bool _process_foreach(Device *dev, Action *act, ExecCtx *e)
     Plug *plug = NULL;
 
     /* we store a plug iterator in the ExecCtx */
-    if (e->plugitr == NULL)
-        e->plugitr = pluglist_iterator_create(dev->plugs);
+    if (e->plugitr == NULL) {
+        if (act->com == PM_POWER_ON_RANGED
+            || act->com == PM_POWER_OFF_RANGED
+            || act->com == PM_POWER_CYCLE_RANGED
+            || act->com == PM_RESET_RANGED
+            || act->com == PM_BEACON_ON_RANGED
+            || act->com == PM_BEACON_OFF_RANGED) {
+            assert(e->plugs);
+            if (!e->pluglist) {
+                if (!(e->pluglist = pluglist_copy_from_list(e->plugs)))
+                    goto cleanup;
+            }
+            e->plugitr = pluglist_iterator_create(e->pluglist);
+        }
+        else
+            e->plugitr = pluglist_iterator_create(dev->plugs);
+    }
 
     /* Each time the inner block is executed, its argument will be
      * a new plug name.  Pick that up here.
@@ -1113,6 +1135,52 @@ static bool _process_setplugstate(Device *dev, Action *act, ExecCtx *e)
     return finished;
 }
 
+static bool _process_setresult(Device *dev, Action *act, ExecCtx *e)
+{
+    bool finished = true;
+    char *plug_name;
+
+    /*
+     * Usage: setresult regex regexstatus interps
+     */
+    plug_name = xregex_match_sub_strdup(dev->xmatch,
+                                        e->cur->u.setresult.plug_mp);
+
+    /* if no plug name, do nothing */
+    if (plug_name) {
+        char *str = xregex_match_sub_strdup(dev->xmatch,
+                                            e->cur->u.setresult.stat_mp);
+        Plug *plug = pluglist_find(dev->plugs, plug_name);
+
+        if (str && plug && plug->node) {
+            InterpResult result = RT_UNKNOWN;
+            ListIterator itr;
+            ResultInterp *i;
+            Arg *arg;
+
+            itr = list_iterator_create(e->cur->u.setresult.interps);
+            while ((i = list_next(itr))) {
+                if (xregex_exec(i->re, str, NULL)) {
+                    result = i->result;
+                    break;
+                }
+            }
+            list_iterator_destroy(itr);
+
+            if ((arg = arglist_find(act->arglist, plug->node))) {
+                arg->result = result;
+                xfree(arg->val);
+                arg->val = xstrdup(str);
+            }
+        }
+        xfree(str);
+        /* if no match, do nothing */
+        xfree(plug_name);
+    }
+
+    return finished;
+}
+
 /* return true if expect is finished */
 static bool _process_expect(Device *dev, Action *act, ExecCtx *e)
 {

src/powerman/device_private.h

@@ -52,13 +52,20 @@ typedef struct {
     xregex_t        re;
 } StateInterp;
 
+typedef struct {
+    InterpResult    result;
+    char           *str;
+    xregex_t        re;
+} ResultInterp;
+
 /*
  * A Script is a list of Stmts.
  */
 typedef enum {
     STMT_SEND,
     STMT_EXPECT,
     STMT_SETPLUGSTATE,
+    STMT_SETRESULT,
     STMT_DELAY,
     STMT_FOREACHPLUG,
     STMT_FOREACHNODE,
@@ -81,6 +88,11 @@ typedef struct {
             int stat_mp;        /* regex subexp match pos of plug status */
             List interps;       /* list of possible interpretations */
         } setplugstate;
+        struct {                /* SETRESULT (regexs refer to prev expect) */
+            int plug_mp;        /* regex subexp match pos of plug name if not */
+            int stat_mp;        /* regex subexp match pos of plug status */
+            List interps;       /* list of possible interpretations */
+        } setresult;
         struct {                /* DELAY */
             struct timeval tv;  /* delay at this point in the script */
         } delay;

src/powerman/parse_lex.l

@@ -133,6 +133,7 @@ pingperiod      return TOK_PING_PERIOD;
 specification   return TOK_SPEC;
 expect          return TOK_EXPECT;
 setplugstate    return TOK_SETPLUGSTATE;
+setresult       return TOK_SETRESULT;
 foreachnode     return TOK_FOREACHNODE;
 foreachplug     return TOK_FOREACHPLUG;
 ifoff           return TOK_IFOFF;
@@ -169,6 +170,7 @@ plug[ \t]+name  return TOK_PLUG_NAME;
 node            return TOK_NODE;
 yes             return TOK_YES;
 no              return TOK_NO;
+success         return TOK_SUCCESS;
 \{              return TOK_BEGIN;
 \}              return TOK_END;
 =               return TOK_EQUALS;