diff --git a/include/pacemaker.h b/include/pacemaker.h index 44d2a82362..6134b4b772 100644 --- a/include/pacemaker.h +++ b/include/pacemaker.h @@ -1,193 +1,198 @@ /* * Copyright 2019 the Pacemaker project contributors * * The version control history for this file may have further details. * * This source code is licensed under the GNU Lesser General Public License * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY. */ #ifndef PACEMAKER__H # define PACEMAKER__H #ifdef __cplusplus extern "C" { #endif /** * \file * \brief High Level API * \ingroup pacemaker */ # include # include /*! * \brief Perform a STONITH action. * * \param[in] st A connection to the STONITH API. * \param[in] target The node receiving the action. * \param[in] action The action to perform. * \param[in] name Who requested the fence action? - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * \param[in] tolerance If a successful action for \p target happened within - * this many seconds, return 0 without performing the - * action again. + * this many ms, return 0 without performing the action + * again. * * \return 0 on success, or various error codes on error. */ int pcmk_fence_action(stonith_t *st, const char *target, const char *action, - const char *name, int timeout, int tolerance); + const char *name, unsigned int timeout, unsigned int tolerance); /*! * \brief List the fencing operations that have occurred for a specific node. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. * \param[in] target The node to get history for. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * \param[in] quiet Suppress most output. * \param[in] verbose Include additional output. * \param[in] broadcast Gather fencing history from all nodes. * \param[in] cleanup Clean up fencing history after listing. * * \return 0 on success, or various error codes on error. */ -int pcmk_fence_history(xmlNodePtr *xml, stonith_t *st, char *target, int timeout, - bool quiet, int verbose, bool broadcast, bool cleanup); +int pcmk_fence_history(xmlNodePtr *xml, stonith_t *st, char *target, + unsigned int timeout, bool quiet, int verbose, + bool broadcast, bool cleanup); /*! * \brief List all installed STONITH agents. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk_fence_installed(xmlNodePtr *xml, stonith_t *st, int timeout); +int pcmk_fence_installed(xmlNodePtr *xml, stonith_t *st, unsigned int timeout); /*! * \brief When was a device last fenced? * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] target The node that was fenced. * \param[in] as_nodeid * * \return 0 on success, or various error codes on error. */ int pcmk_fence_last(xmlNodePtr *xml, const char *target, bool as_nodeid); /*! * \brief List nodes that can be fenced. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. * \param[in] agent The agent that can do the fencing. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk_fence_list_targets(xmlNodePtr *xml, stonith_t *st, char *agent, int timeout); +int pcmk_fence_list_targets(xmlNodePtr *xml, stonith_t *st, char *agent, + unsigned int timeout); /*! * \brief Get metadata for a resource. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. * \param[in] agent The fence agent to get metadata for. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk_fence_metadata(xmlNodePtr *xml, stonith_t *st, char *agent, int timeout); +int pcmk_fence_metadata(xmlNodePtr *xml, stonith_t *st, char *agent, + unsigned int timeout); /*! * \brief List registered fence devices. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. * \param[in] target If not NULL, only return devices that can fence * this node. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, char *target, int timeout); +int pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, char *target, + unsigned int timeout); /*! * \brief Register a fencing level for a specific node, node regex, or attribute. * * \p target can take three different forms: * - name=value, in which case \p target is an attribute. * - @pattern, in which case \p target is a node regex. * - Otherwise, \p target is a node name. * * \param[in] st A connection to the STONITH API. * \param[in] target The object to register a fencing level for. * \param[in] fence_level Index number of level to add. * \param[in] devices Devices to use in level. * * \return 0 on success, or various error codes on error. */ int pcmk_fence_register_level(stonith_t *st, char *target, int fence_level, stonith_key_value_t *devices); /*! * \brief Unregister a fencing level for a specific node, node regex, or attribute. * * \p target can take three different forms: * - name=value, in which case \p target is an attribute. * - @pattern, in which case \p target is a node regex. * - Otherwise, \p target is a node name. * * \param[in] st A connection to the STONITH API. * \param[in] target The object to unregister a fencing level for. * \param[in] fence_level Index number of level to remove. * * \return 0 on success, or various error codes on error. */ int pcmk_fence_unregister_level(stonith_t *st, char *target, int fence_level); /*! * \brief Validate a STONITH device configuration. * * \note If \p xml is not NULL, it will be freed first and the previous * contents lost. * * \param[in,out] xml The destination for the result, as an XML tree. * \param[in] st A connection to the STONITH API. * \param[in] agent The agent to validate (for example, "fence_xvm"). * \param[in] id STONITH device ID (may be NULL). * \param[in] params STONITH device configuration parameters. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ int pcmk_fence_validate(xmlNodePtr *xml, stonith_t *st, const char *agent, - const char *id, stonith_key_value_t *params, int timeout); + const char *id, stonith_key_value_t *params, + unsigned int timeout); #ifdef __cplusplus } #endif #endif diff --git a/include/pcmki/pcmki_fence.h b/include/pcmki/pcmki_fence.h index c860f6fea0..8f28232206 100644 --- a/include/pcmki/pcmki_fence.h +++ b/include/pcmki/pcmki_fence.h @@ -1,216 +1,220 @@ /* * Copyright 2019 the Pacemaker project contributors * * The version control history for this file may have further details. * * This source code is licensed under the GNU Lesser General Public License * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY. */ #ifndef PCMKI_STONITH_H # define PCMKI_STONITH_H # include # include /*! * \brief Perform a STONITH action. * * \note This is the internal version of pcmk_fence_action(). External users * of the pacemaker API should use that function instead. * * \param[in] st A connection to the STONITH API. * \param[in] target The node receiving the action. * \param[in] action The action to perform. * \param[in] name Who requested the fence action? - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * \param[in] tolerance If a successful action for \p target happened within - * this many seconds, return 0 without performing the - * action again. + * this many ms, return 0 without performing the action + * again. * * \return 0 on success, or various error codes on error. */ int pcmk__fence_action(stonith_t *st, const char *target, const char *action, - const char *name, int timeout, int tolerance); + const char *name, unsigned int timeout, unsigned int tolerance); /*! * \brief List the fencing operations that have occurred for a specific node. * * \note This is the internal version of pcmk_fence_history(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. * \param[in] target The node to get history for. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * \param[in] quiet Suppress most output. * \param[in] verbose Include additional output. * \param[in] broadcast Gather fencing history from all nodes. * \param[in] cleanup Clean up fencing history after listing. * * \return 0 on success, or various error codes on error. */ int pcmk__fence_history(pcmk__output_t *out, stonith_t *st, char *target, - int timeout, bool quiet, int verbose, bool broadcast, - bool cleanup); + unsigned int timeout, bool quiet, int verbose, + bool broadcast, bool cleanup); /** * \brief List all installed STONITH agents. * * \note This is the internal version of pcmk_fence_installed(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk__fence_installed(pcmk__output_t *out, stonith_t *st, int timeout); +int pcmk__fence_installed(pcmk__output_t *out, stonith_t *st, unsigned int timeout); /*! * \brief When was a device last fenced? * * \note This is the internal version of pcmk_fence_last(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] target The node that was fenced. * \param[in] as_nodeid * * \return 0 on success, or various error codes on error. */ int pcmk__fence_last(pcmk__output_t *out, const char *target, bool as_nodeid); /*! * \brief List nodes that can be fenced. * * \note This is the internal version of pcmk_fence_list_targets(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. * \param[in] agent The agent that can do the fencing. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk__fence_list_targets(pcmk__output_t *out, stonith_t *st, char *agent, int timeout); +int pcmk__fence_list_targets(pcmk__output_t *out, stonith_t *st, char *agent, + unsigned int timeout); /*! * \brief Get metadata for a resource. * * \note This is the internal version of pcmk_fence_metadata(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. * \param[in] agent The fence agent to get metadata for. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk__fence_metadata(pcmk__output_t *out, stonith_t *st, char *agent, int timeout); +int pcmk__fence_metadata(pcmk__output_t *out, stonith_t *st, char *agent, + unsigned int timeout); /*! * \brief List registered fence devices. * * \note This is the internal version of pcmk_fence_metadata(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. * \param[in] target If not NULL, only return devices that can fence * this node. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ -int pcmk__fence_registered(pcmk__output_t *out, stonith_t *st, char *target, int timeout); +int pcmk__fence_registered(pcmk__output_t *out, stonith_t *st, char *target, + unsigned int timeout); /*! * \brief Register a fencing level for a specific node, node regex, or attribute. * * \note This is the internal version of pcmk_fence_register_level(). External users * of the pacemaker API should use that function instead. * * \p target can take three different forms: * - name=value, in which case \p target is an attribute. * - @pattern, in which case \p target is a node regex. * - Otherwise, \p target is a node name. * * \param[in] st A connection to the STONITH API. * \param[in] target The object to register a fencing level for. * \param[in] fence_level Index number of level to add. * \param[in] devices Devices to use in level. * * \return 0 on success, or various error codes on error. */ int pcmk__fence_register_level(stonith_t *st, char *target, int fence_level, stonith_key_value_t *devices); /*! * \brief Unregister a fencing level for a specific node, node regex, or attribute. * * \note This is the internal version of pcmk_fence_unregister_level(). External users * of the pacemaker API should use that function instead. * * \p target can take three different forms: * - name=value, in which case \p target is an attribute. * - @pattern, in which case \p target is a node regex. * - Otherwise, \p target is a node name. * * \param[in] st A connection to the STONITH API. * \param[in] target The object to unregister a fencing level for. * \param[in] fence_level Index number of level to remove. * * \return 0 on success, or various error codes on error. */ int pcmk__fence_unregister_level(stonith_t *st, char *target, int fence_level); /** * \brief Validate a STONITH device configuration. * * \note This is the internal version of pcmk_stonith_validate(). External users * of the pacemaker API should use that function instead. * * \note \p out should be initialized with pcmk__output_new() before calling this * function and destroyed with out->finish and pcmk__output_free() before * reusing it with any other functions in this library. * * \param[in,out] out The output functions structure. * \param[in] st A connection to the STONITH API. * \param[in] agent The agent to validate (for example, "fence_xvm"). * \param[in] id STONITH device ID (may be NULL). * \param[in] params STONITH device configuration parameters. - * \param[in] timeout How long to wait for the operation to complete (in seconds). + * \param[in] timeout How long to wait for the operation to complete (in ms). * * \return 0 on success, or various error codes on error. */ int pcmk__fence_validate(pcmk__output_t *out, stonith_t *st, const char *agent, - const char *id, stonith_key_value_t *params, int timeout); + const char *id, stonith_key_value_t *params, + unsigned int timeout); #endif diff --git a/lib/pacemaker/pcmk_fence.c b/lib/pacemaker/pcmk_fence.c index a219ee88a6..62afabfe9c 100644 --- a/lib/pacemaker/pcmk_fence.c +++ b/lib/pacemaker/pcmk_fence.c @@ -1,449 +1,458 @@ /* * Copyright 2009-2019 the Pacemaker project contributors * * The version control history for this file may have further details. * * This source code is licensed under the GNU General Public License version 2 * or later (GPLv2+) WITHOUT ANY WARRANTY. */ #include #include #include #include #include #include #include #include #include #include static int st_opts = st_opt_sync_call | st_opt_allow_suicide; static GMainLoop *mainloop = NULL; static struct { stonith_t *st; const char *target; const char *action; char *name; - int timeout; - int tolerance; + unsigned int timeout; + unsigned int tolerance; int rc; } async_fence_data; static int handle_level(stonith_t *st, char *target, int fence_level, stonith_key_value_t *devices, bool added) { char *node = NULL; char *pattern = NULL; char *name = NULL; char *value = NULL; if (target == NULL) { // Not really possible, but makes static analysis happy return -EINVAL; } /* Determine if targeting by attribute, node name pattern or node name */ value = strchr(target, '='); if (value != NULL) { name = target; *value++ = '\0'; } else if (*target == '@') { pattern = target + 1; } else { node = target; } /* Register or unregister level as appropriate */ if (added) { return st->cmds->register_level_full(st, st_opts, node, pattern, name, value, fence_level, devices); } return st->cmds->remove_level_full(st, st_opts, node, pattern, name, value, fence_level); } static void notify_callback(stonith_t * st, stonith_event_t * e) { if (e->result != pcmk_ok) { return; } if (safe_str_eq(async_fence_data.target, e->target) && safe_str_eq(async_fence_data.action, e->action)) { async_fence_data.rc = e->result; g_main_loop_quit(mainloop); } } static void fence_callback(stonith_t * stonith, stonith_callback_data_t * data) { async_fence_data.rc = data->rc; g_main_loop_quit(mainloop); } static gboolean async_fence_helper(gpointer user_data) { stonith_t *st = async_fence_data.st; int call_id = 0; int rc = stonith_api_connect_retry(st, async_fence_data.name, 10); if (rc != pcmk_ok) { fprintf(stderr, "Could not connect to fencer: %s\n", pcmk_strerror(rc)); g_main_loop_quit(mainloop); return TRUE; } st->cmds->register_notification(st, T_STONITH_NOTIFY_FENCE, notify_callback); call_id = st->cmds->fence(st, st_opt_allow_suicide, async_fence_data.target, async_fence_data.action, - async_fence_data.timeout, async_fence_data.tolerance); + async_fence_data.timeout/1000, + async_fence_data.tolerance/1000); if (call_id < 0) { g_main_loop_quit(mainloop); return TRUE; } st->cmds->register_callback(st, call_id, - async_fence_data.timeout, + async_fence_data.timeout/1000, st_opt_timeout_updates, NULL, "callback", fence_callback); return TRUE; } int pcmk__fence_action(stonith_t *st, const char *target, const char *action, - const char *name, int timeout, int tolerance) + const char *name, unsigned int timeout, unsigned int tolerance) { crm_trigger_t *trig; async_fence_data.st = st; async_fence_data.name = strdup(name); async_fence_data.target = target; async_fence_data.action = action; async_fence_data.timeout = timeout; async_fence_data.tolerance = tolerance; async_fence_data.rc = -1; trig = mainloop_add_trigger(G_PRIORITY_HIGH, async_fence_helper, NULL); mainloop_set_trigger(trig); mainloop = g_main_loop_new(NULL, FALSE); g_main_loop_run(mainloop); free(async_fence_data.name); return async_fence_data.rc; } int pcmk_fence_action(stonith_t *st, const char *target, const char *action, - const char *name, int timeout, int tolerance) { + const char *name, unsigned int timeout, unsigned int tolerance) { return pcmk__fence_action(st, target, action, name, timeout, tolerance); } int pcmk__fence_history(pcmk__output_t *out, stonith_t *st, char *target, - int timeout, bool quiet, int verbose, bool broadcast, - bool cleanup) { + unsigned int timeout, bool quiet, int verbose, + bool broadcast, bool cleanup) { stonith_history_t *history = NULL, *hp, *latest = NULL; int rc = 0; if (!quiet) { if (cleanup) { out->info(out, "cleaning up fencing-history%s%s", target ? " for node " : "", target ? target : ""); } if (broadcast) { out->info(out, "gather fencing-history from all nodes"); } } rc = st->cmds->history(st, st_opts | (cleanup ? st_opt_cleanup : 0) | broadcast ? st_opt_broadcast : 0, safe_str_eq(target, "*") ? NULL : target, - &history, timeout); + &history, timeout/1000); out->begin_list(out, "event", "events", "Fencing history"); history = stonith__sort_history(history); for (hp = history; hp; hp = hp->next) { if (hp->state == st_done) { latest = hp; } if (quiet || !verbose) { continue; } out->message(out, "stonith-event", hp, 1, stonith__later_succeeded(hp, history)); out->increment_list(out); } if (latest) { if (quiet && out->supports_quiet) { out->info(out, "%lld", (long long) latest->completed); } else if (!verbose) { // already printed if verbose out->message(out, "stonith-event", latest, 0, FALSE); out->increment_list(out); } } out->end_list(out); stonith_history_free(history); return rc; } int -pcmk_fence_history(xmlNodePtr *xml, stonith_t *st, char *target, int timeout, +pcmk_fence_history(xmlNodePtr *xml, stonith_t *st, char *target, unsigned int timeout, bool quiet, int verbose, bool broadcast, bool cleanup) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_history(out, st, target, timeout, quiet, verbose, broadcast, cleanup); pcmk__out_epilogue(out, xml, rc); return rc; } int -pcmk__fence_installed(pcmk__output_t *out, stonith_t *st, int timeout) { +pcmk__fence_installed(pcmk__output_t *out, stonith_t *st, unsigned int timeout) { stonith_key_value_t *devices = NULL; int rc; - rc = st->cmds->list_agents(st, st_opt_sync_call, NULL, &devices, timeout); + rc = st->cmds->list_agents(st, st_opt_sync_call, NULL, &devices, timeout/1000); if (rc < 0) { return rc; } out->begin_list(out, "fence device", "fence devices", "Installed fence devices"); for (stonith_key_value_t *dIter = devices; dIter; dIter = dIter->next) { out->list_item(out, "device", "%s", dIter->value); } out->end_list(out); stonith_key_value_freeall(devices, 1, 1); return 0; } int -pcmk_fence_installed(xmlNodePtr *xml, stonith_t *st, int timeout) { +pcmk_fence_installed(xmlNodePtr *xml, stonith_t *st, unsigned int timeout) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_installed(out, st, timeout); pcmk__out_epilogue(out, xml, rc); return rc; } int pcmk__fence_last(pcmk__output_t *out, const char *target, bool as_nodeid) { time_t when = 0; if (target == NULL) { return 0; } if (as_nodeid) { when = stonith_api_time(atol(target), NULL, FALSE); } else { when = stonith_api_time(0, target, FALSE); } out->message(out, "last-fenced", target, when); return 0; } int pcmk_fence_last(xmlNodePtr *xml, const char *target, bool as_nodeid) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_last(out, target, as_nodeid); pcmk__out_epilogue(out, xml, rc); return rc; } int -pcmk__fence_list_targets(pcmk__output_t *out, stonith_t *st, char *agent, int timeout) { +pcmk__fence_list_targets(pcmk__output_t *out, stonith_t *st, char *agent, + unsigned int timeout) { GList *targets = NULL; char *lists = NULL; int rc = 0; - rc = st->cmds->list(st, st_opts, agent, &lists, timeout); + rc = st->cmds->list(st, st_opts, agent, &lists, timeout/1000); if (rc != 0) { return rc; } targets = stonith__parse_targets(lists); out->begin_list(out, "fence target", "fence targets", "Fence Targets"); while (targets != NULL) { out->list_item(out, NULL, "%s", (const char *) targets->data); targets = targets->next; } out->end_list(out); free(lists); return 0; } int -pcmk_fence_list_targets(xmlNodePtr *xml, stonith_t *st, char *agent, int timeout) { +pcmk_fence_list_targets(xmlNodePtr *xml, stonith_t *st, char *agent, + unsigned int timeout) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_list_targets(out, st, agent, timeout); pcmk__out_epilogue(out, xml, rc); return rc; } int -pcmk__fence_metadata(pcmk__output_t *out, stonith_t *st, char *agent, int timeout) { +pcmk__fence_metadata(pcmk__output_t *out, stonith_t *st, char *agent, + unsigned int timeout) { char *buffer = NULL; int rc = st->cmds->metadata(st, st_opt_sync_call, agent, NULL, &buffer, - timeout); + timeout/1000); if (rc != pcmk_ok) { return rc; } out->output_xml(out, "metadata", buffer); free(buffer); return rc; } int -pcmk_fence_metadata(xmlNodePtr *xml, stonith_t *st, char *agent, int timeout) { +pcmk_fence_metadata(xmlNodePtr *xml, stonith_t *st, char *agent, + unsigned int timeout) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_metadata(out, st, agent, timeout); pcmk__out_epilogue(out, xml, rc); return rc; } int -pcmk__fence_registered(pcmk__output_t *out, stonith_t *st, char *target, int timeout) { +pcmk__fence_registered(pcmk__output_t *out, stonith_t *st, char *target, + unsigned int timeout) { stonith_key_value_t *devices = NULL; int rc; - rc = st->cmds->query(st, st_opts, target, &devices, timeout); + rc = st->cmds->query(st, st_opts, target, &devices, timeout/1000); if (rc < 0) { return rc; } out->begin_list(out, "fence device", "fence devices", "Registered fence devices"); for (stonith_key_value_t *dIter = devices; dIter; dIter = dIter->next) { out->list_item(out, "device", "%s", dIter->value); } out->end_list(out); stonith_key_value_freeall(devices, 1, 1); return 0; } int -pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, char *target, int timeout) { +pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, char *target, + unsigned int timeout) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_registered(out, st, target, timeout); pcmk__out_epilogue(out, xml, rc); return rc; } int pcmk__fence_register_level(stonith_t *st, char *target, int fence_level, stonith_key_value_t *devices) { return handle_level(st, target, fence_level, devices, true); } int pcmk_fence_register_level(stonith_t *st, char *target, int fence_level, stonith_key_value_t *devices) { return pcmk__fence_register_level(st, target, fence_level, devices); } int pcmk__fence_unregister_level(stonith_t *st, char *target, int fence_level) { return handle_level(st, target, fence_level, NULL, false); } int pcmk_fence_unregister_level(stonith_t *st, char *target, int fence_level) { return pcmk__fence_unregister_level(st, target, fence_level); } int pcmk__fence_validate(pcmk__output_t *out, stonith_t *st, const char *agent, - const char *id, stonith_key_value_t *params, int timeout) { + const char *id, stonith_key_value_t *params, + unsigned int timeout) { char *output = NULL; char *error_output = NULL; int rc; rc = st->cmds->validate(st, st_opt_sync_call, id, NULL, agent, params, - timeout, &output, &error_output); + timeout/1000, &output, &error_output); out->message(out, "validate", agent, id, output, error_output, rc); return rc; } int pcmk_fence_validate(xmlNodePtr *xml, stonith_t *st, const char *agent, - const char *id, stonith_key_value_t *params, int timeout) { + const char *id, stonith_key_value_t *params, + unsigned int timeout) { pcmk__output_t *out = NULL; int rc = 0; rc = pcmk__out_prologue(&out, xml); if (rc != 0) { return rc; } rc = pcmk__fence_validate(out, st, agent, id, params, timeout); pcmk__out_epilogue(out, xml, rc); return rc; }