Merge branch 'stonith_timeout_3' of https://github.com/davidvossel/pacemaker

Conflicts:
	lrmd/regression.py.in

Author: beekhof

crmd/te_actions.c

@@ -147,7 +147,7 @@ te_fence_node(crm_graph_t * graph, crm_action_t * action)
 
     stonith_api->cmds->register_callback(
         stonith_api, rc, transition_graph->stonith_timeout / 1000,
-        FALSE, generate_transition_key(transition_graph->id, action->id, 0, te_uuid),
+        st_opt_timeout_updates, generate_transition_key(transition_graph->id, action->id, 0, te_uuid),
         "tengine_stonith_callback", tengine_stonith_callback);
 
     return TRUE;

fencing/commands.c

@@ -52,6 +52,28 @@ static int active_children = 0;
 static gboolean stonith_device_dispatch(gpointer user_data);
 static void st_child_done(GPid pid, gint status, gpointer user_data);
 
+static int
+get_action_timeout(stonith_device_t *device, const char *action, int default_timeout)
+{
+    char buffer[512] = { 0, };
+    char *value = NULL;
+
+    CRM_CHECK(action != NULL, return default_timeout);
+
+    if (!device->params) {
+        return default_timeout;
+    }
+
+    snprintf(buffer, sizeof(buffer) - 1, "pcmk_%s_timeout", action);
+    value = g_hash_table_lookup(device->params, buffer);
+
+    if (!value) {
+        return default_timeout;
+    }
+
+    return  atoi(value);
+}
+
 static void free_async_command(async_command_t *cmd)
 {
     if (!cmd) {
@@ -83,7 +105,8 @@ static async_command_t *create_async_command(xmlNode *msg)
     cmd = calloc(1, sizeof(async_command_t));
     crm_element_value_int(msg, F_STONITH_CALLID,   &(cmd->id));
     crm_element_value_int(msg, F_STONITH_CALLOPTS, &(cmd->options));
-    crm_element_value_int(msg, F_STONITH_TIMEOUT,  &(cmd->timeout));
+    crm_element_value_int(msg, F_STONITH_TIMEOUT,  &(cmd->default_timeout));
+    cmd->timeout = cmd->default_timeout;
 
     cmd->origin = crm_element_value_copy(msg, F_ORIG);
     cmd->remote = crm_element_value_copy(msg, F_STONITH_REMOTE);
@@ -179,6 +202,7 @@ static void schedule_stonith_command(async_command_t *cmd, stonith_device_t *dev
     }
 
     cmd->device = strdup(device->id);
+    cmd->timeout = get_action_timeout(device, cmd->action, cmd->default_timeout);
 
     crm_debug("Scheduling %s on %s for %s (timeout=%dms)", cmd->action, device->id,
               cmd->remote?cmd->remote:cmd->client, cmd->timeout);
@@ -745,6 +769,7 @@ static int stonith_query(xmlNode *msg, xmlNode **list)
 {
     struct device_search_s search;
     int available_devices = 0;
+    const char *action = NULL;
     xmlNode *dev = get_xpath_object("//@"F_STONITH_TARGET, msg, LOG_DEBUG_3);
 
     search.host = NULL;
@@ -760,6 +785,8 @@ static int stonith_query(xmlNode *msg, xmlNode **list)
             }
             return pcmk_ok;
         }
+
+        action = crm_element_value(dev, F_STONITH_ACTION);
     }
 
     crm_log_xml_debug(msg, "Query");
@@ -781,10 +808,15 @@ static int stonith_query(xmlNode *msg, xmlNode **list)
         crm_xml_add_int(*list, "st-available-devices", available_devices);
         for(lpc = search.capable; lpc != NULL; lpc = lpc->next) {
             stonith_device_t *device = (stonith_device_t*)lpc->data;
+            int action_specific_timeout = get_action_timeout(device, action, 0);
+
             dev = create_xml_node(*list, F_STONITH_DEVICE);
             crm_xml_add(dev, XML_ATTR_ID, device->id);
             crm_xml_add(dev, "namespace", device->namespace);
             crm_xml_add(dev, "agent", device->agent);
+            if (action_specific_timeout) {
+                crm_xml_add_int(dev, F_STONITH_ACTION_TIMEOUT, action_specific_timeout);
+            }
             if(search.host == NULL) {
                 xmlNode *attrs = create_xml_node(dev, XML_TAG_ATTRS);
                 g_hash_table_foreach(device->params, hash2field, attrs);
@@ -1238,6 +1270,14 @@ stonith_command(stonith_client_t *client, uint32_t id, uint32_t flags, xmlNode *
     } else if(crm_str_eq(op, STONITH_OP_EXEC, TRUE)) {
         rc = stonith_device_action(request, &output);
 
+    } else if (crm_str_eq(op, STONITH_OP_TIMEOUT_UPDATE, TRUE)) {
+        const char *call_id = crm_element_value(request, F_STONITH_CALLID);
+        const char *client_id = crm_element_value(request, F_STONITH_CLIENTID);
+        int op_timeout = 0;
+
+        crm_element_value_int(request, F_STONITH_TIMEOUT, &op_timeout);
+        do_stonith_async_timeout_update(client_id, call_id, op_timeout);
+        return;
     } else if(is_reply && crm_str_eq(op, STONITH_OP_QUERY, TRUE)) {
         process_remote_stonith_query(request);
         return;

fencing/internal.h

@@ -82,6 +82,9 @@ extern xmlNode *stonith_construct_reply(xmlNode * request, char *output, xmlNode
 extern xmlNode *stonith_construct_async_reply(async_command_t * cmd, const char *output, xmlNode * data,
                                               int rc);;
 
+void
+do_stonith_async_timeout_update(const char *client, const char *call_id, int timeout);
+
 extern void do_stonith_notify(int options, const char *type, int result, xmlNode * data, const char *remote);
 
 extern remote_fencing_op_t *initiate_remote_stonith_op(stonith_client_t * client, xmlNode * request,

fencing/main.c

@@ -136,6 +136,7 @@ st_ipc_dispatch(qb_ipcs_connection_t *c, void *data, size_t size)
 
     crm_xml_add(request, F_STONITH_CLIENTID, client->id);
     crm_xml_add(request, F_STONITH_CLIENTNAME, client->name);
+    crm_xml_add(request, F_STONITH_CLIENTNODE, stonith_our_uname);
 
     crm_log_xml_trace(request, "Client[inbound]");
     stonith_command(client, id, flags, request, NULL);
@@ -363,6 +364,35 @@ stonith_notify_client(gpointer key, gpointer value, gpointer user_data)
     }
 }
 
+void
+do_stonith_async_timeout_update(const char *client_id, const char *call_id, int timeout)
+{
+    stonith_client_t *client = NULL;
+    xmlNode *notify_data = NULL;
+
+    if (!timeout || !call_id || !client_id) {
+        return;
+    }
+
+    client = g_hash_table_lookup(client_list, client_id);
+    if (!client) {
+        return;
+    }
+
+    notify_data = create_xml_node(NULL, T_STONITH_TIMEOUT_VALUE);
+    crm_xml_add(notify_data, F_TYPE, T_STONITH_TIMEOUT_VALUE);
+    crm_xml_add(notify_data, F_STONITH_CALLID, call_id);
+    crm_xml_add_int(notify_data, F_STONITH_TIMEOUT, timeout);
+
+    crm_trace("timeout update is %d for client %s and call id %s", timeout, client_id, call_id);
+
+    if (client->channel) {
+        crm_ipcs_send(client->channel, 0, notify_data, crm_ipc_server_event);
+    }
+
+    free_xml(notify_data);
+}
+
 void
 do_stonith_notify(
     int options, const char *type, int result, xmlNode *data,
@@ -748,7 +778,7 @@ main(int argc, char ** argv)
         printf(" <parameters>\n");
 
         printf("  <parameter name=\"stonith-timeout\" unique=\"0\">\n");
-        printf("    <shortdesc lang=\"en\">How long to wait for the STONITH action to complete.</shortdesc>\n");
+        printf("    <shortdesc lang=\"en\">How long to wait for the STONITH action to complete per a stonith device.</shortdesc>\n");
         printf("    <longdesc lang=\"en\">Overrides the stonith-timeout cluster property</longdesc>\n");
         printf("    <content type=\"time\" default=\"60s\"/>\n");
         printf("  </parameter>\n");