diff --git a/lib/plugins/lrm/raexecstonith.c b/lib/plugins/lrm/raexecstonith.c
index 82bdc156e1..6d8bdf316d 100644
--- a/lib/plugins/lrm/raexecstonith.c
+++ b/lib/plugins/lrm/raexecstonith.c
@@ -1,341 +1,341 @@
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* File: raexecocf.c
* Author: Sun Jiang Dong <sunjd@cn.ibm.com>
* Copyright (c) 2004 International Business Machines
*
* This code implements the Resource Agent Plugin Module for LSB style.
* It's a part of Local Resource Manager. Currently it's used by lrmd only.
*/
#include <portability.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <errno.h>
#include <glib.h>
#include <clplumbing/cl_log.h>
#include <pils/plugin.h>
#include <dirent.h>
#include <libgen.h> /* Add it for compiling on OSX */
#include <config.h>
#include <lrm/raexec.h>
#include <fencing/stonithd_api.h>
#include <stonith/stonith.h>
# define PIL_PLUGINTYPE RA_EXEC_TYPE
# define PIL_PLUGINTYPE_S "RAExec"
# define PIL_PLUGINLICENSE LICENSE_PUBDOM
# define PIL_PLUGINLICENSEURL URL_PUBDOM
# define PIL_PLUGIN stonith
# define PIL_PLUGIN_S "stonith"
static PIL_rc close_stonithRA(PILInterface*, void* ud_interface);
/* static const char * RA_PATH = STONITH_RA_DIR; */
/* Temporarily use it */
-static const char * RA_PATH = "/usr/lib/stonith/plugins/stonith/";
+static const char * RA_PATH = HA_LIBDIR "/stonith/plugins/stonith/";
/* The begin of exported function list */
static int execra(const char * rsc_id,
const char * rsc_type,
const char * provider,
const char * op_type,
const int timeout,
GHashTable * params);
static uniform_ret_execra_t map_ra_retvalue(int ret_execra
, const char * op_type, const char * std_output);
static int get_resource_list(GList ** rsc_info);
static char* get_resource_meta(const char* rsc_type, const char* provider);
static int get_provider_list(const char* op_type, GList ** providers);
/* The end of exported function list */
/* The begin of internal used function & data list */
static int get_providers(const char* class_path, const char* op_type,
GList ** providers);
static void stonithRA_ops_callback(stonithRA_ops_t * op, void * private_data);
static int exit_value;
/* The end of internal function & data list */
/* Rource agent execution plugin operations */
static struct RAExecOps raops =
{ execra,
map_ra_retvalue,
get_resource_list,
get_provider_list,
get_resource_meta
};
static const char * meta_data1 = "\n"
"<?xml version=\"1.0\"?>\n"
"<!DOCTYPE resource-agent SYSTEM \"ra-api-1.dtd\">\n"
"<resource-agent name=\"";
static const char * meta_data2 =
"\" version=\"0.1\">\n"
" <version>1.0</version>\n";
static const char * meta_data3 =
" <actions>\n"
" <action name=\"start\" timeout=\"15\" />\n"
" <action name=\"stop\" timeout=\"15\" />\n"
" <action name=\"status\" timeout=\"15\" />\n"
" <action name=\"monitor\" timeout=\"15\" interval=\"15\" start-delay=\"15\" />\n"
" <action name=\"meta-data\" timeout=\"15\" />\n"
" </actions>\n"
" <special tag=\"heartbeat\">\n"
" <version>2.0</version>\n"
" </special>\n"
"</resource-agent>\n";
static const char * no_parameter_info = "<!-- No parameter segment --->";
PIL_PLUGIN_BOILERPLATE2("1.0", Debug);
static const PILPluginImports* PluginImports;
static PILPlugin* OurPlugin;
static PILInterface* OurInterface;
static void* OurImports;
static void* interfprivate;
/*
* Our plugin initialization and registration function
* It gets called when the plugin gets loaded.
*/
PIL_rc
PIL_PLUGIN_INIT(PILPlugin * us, const PILPluginImports* imports);
PIL_rc
PIL_PLUGIN_INIT(PILPlugin * us, const PILPluginImports* imports)
{
/* Force the compiler to do a little type checking */
(void)(PILPluginInitFun)PIL_PLUGIN_INIT;
PluginImports = imports;
OurPlugin = us;
/* Register ourself as a plugin */
imports->register_plugin(us, &OurPIExports);
/* Register our interfaces */
return imports->register_interface(us, PIL_PLUGINTYPE_S, PIL_PLUGIN_S,
&raops, close_stonithRA, &OurInterface, &OurImports,
interfprivate);
}
static PIL_rc
close_stonithRA(PILInterface* pif, void* ud_interface)
{
return PIL_OK;
}
/*
* Most of the oprations will be sent to sotnithd directly, such as 'start',
* 'stop', 'monitor'. And others like 'meta-data' will be handled by itself
* locally.
* Some of important parameters' name:
* config_file
* config_string
*/
static int
execra(const char * rsc_id, const char * rsc_type, const char * provider,
const char * op_type,const int timeout, GHashTable * params)
{
stonithRA_ops_t * op;
int call_id = -1;
char buffer_tmp[32];
/* Handling "meta-data" operation in a special way.
* Now handle "meta-data" operation locally.
* Should be changed in the future?
*/
if ( 0 == STRNCMP_CONST(op_type, "meta-data")) {
char * tmp;
tmp = get_resource_meta(rsc_type, provider);
printf("%s", tmp);
g_free(tmp);
exit(0);
}
g_snprintf(buffer_tmp, sizeof(buffer_tmp), "%s_%d"
, "STONITH_RA_EXEC", getpid());
if (ST_OK != stonithd_signon(buffer_tmp)) {
cl_log(LOG_ERR, "STONITH_RA_EXEC: Cannot sign on the stonithd.");
exit(EXECRA_UNKNOWN_ERROR);
}
stonithd_set_stonithRA_ops_callback(stonithRA_ops_callback, &call_id);
/* Temporarily donnot use it, but how to deal with the global OCF
* variables. This is a important thing to think about and do.
*/
/* send the RA operation to stonithd to simulate a RA's actions */
cl_log(LOG_DEBUG, "Will send the stonith RA operation to stonithd: "
"%s %s", rsc_type, op_type);
op = g_new(stonithRA_ops_t, 1);
op->ra_name = g_strdup(rsc_type);
op->op_type = g_strdup(op_type);
op->params = params;
op->rsc_id = g_strdup(rsc_id);
if (ST_OK != stonithd_virtual_stonithRA_ops(op, &call_id)) {
cl_log(LOG_ERR, "sending stonithRA op to stonithd failed.");
/* Need to improve the granularity for error return code */
stonithd_signoff();
exit(EXECRA_EXEC_UNKNOWN_ERROR);
}
cl_log(LOG_DEBUG, "Waiting until the final result returned.");
/* May be redundant */
/*
while (stonithd_op_result_ready() != TRUE) {
;
}
*/
cl_log(LOG_DEBUG, "Will call stonithd_receive_ops_result.");
if (ST_OK != stonithd_receive_ops_result(TRUE)) {
cl_log(LOG_ERR, "stonithd_receive_ops_result failed.");
/* Need to improve the granularity for error return code */
stonithd_signoff();
exit(EXECRA_EXEC_UNKNOWN_ERROR);
}
/* exit_value will be setted by the callback function */
g_free(op->ra_name);
g_free(op->op_type);
g_free(op->rsc_id);
g_free(op);
stonithd_signoff();
cl_log(LOG_DEBUG, "stonithRA orignal exit code=%d", exit_value);
exit(map_ra_retvalue(exit_value, op_type, NULL));
}
static void
stonithRA_ops_callback(stonithRA_ops_t * op, void * private_data)
{
cl_log(LOG_DEBUG, "setting exit code=%d", exit_value);
exit_value = op->op_result;
}
static uniform_ret_execra_t
map_ra_retvalue(int ret_execra, const char * op_type, const char * std_output)
{
/* Because the UNIFORM_RET_EXECRA is compatible with OCF standard, no
* actual mapping except validating, which ensure the return code
* will be in the range 0 to 7. Too strict?
*/
if (ret_execra < 0 || ret_execra > 7) {
cl_log(LOG_WARNING, "mapped the invalid return code %d."
, ret_execra);
ret_execra = EXECRA_UNKNOWN_ERROR;
}
return ret_execra;
}
static int
get_resource_list(GList ** rsc_info)
{
cl_log(LOG_ERR, "get_resource_list: begin.");
if ( rsc_info == NULL ) {
cl_log(LOG_ERR, "Parameter error: get_resource_list");
return -2;
}
if ( *rsc_info != NULL ) {
cl_log(LOG_ERR, "Parameter error: get_resource_list."\
"will cause memory leak.");
*rsc_info = NULL;
}
if (ST_OK != stonithd_signon("STONITH_RA")) {
cl_log(LOG_ERR, "Can not signon to the stonithd.");
return -1;
}
return stonithd_list_stonith_types(rsc_info);
}
static int
get_provider_list(const char* op_type, GList ** providers)
{
int ret;
ret = get_providers(RA_PATH, op_type, providers);
if (0>ret) {
cl_log(LOG_ERR, "scandir failed in stonith RA plugin");
}
return ret;
}
static char *
get_resource_meta(const char* rsc_type, const char* provider)
{
char * buffer;
const char * tmp = NULL;
Stonith * stonith_obj = NULL;
if ( provider != NULL ) {
cl_log(LOG_ERR, "stonithRA plugin: now donnot take the provider"
" into account.");
return NULL;
}
stonith_obj = stonith_new(rsc_type);
tmp = stonith_get_info(stonith_obj, ST_CONF_XML);
if (tmp == NULL) {
cl_log(LOG_WARNING, "stonithRA plugin: cannot get the parameter"
" segment of %s's metadata.", rsc_type);
tmp = no_parameter_info;
}
buffer = g_new(char, strlen(meta_data1) + strlen(meta_data2)
+ strlen(tmp) + strlen(meta_data3) + 1);
sprintf(buffer, "%s%s%s%s", meta_data1, meta_data2, tmp, meta_data3);
stonith_delete(stonith_obj);
return buffer;
}
/*
* Currently should return *providers = NULL, but rmain the old code for
* possible unsing in the future
*/
static int
get_providers(const char* class_path, const char* op_type, GList ** providers)
{
if ( providers == NULL ) {
cl_log(LOG_ERR, "Parameter error: get_providers");
return -2;
}
if ( *providers != NULL ) {
cl_log(LOG_ERR, "Parameter error: get_providers."\
"will cause memory leak.");
*providers = NULL;
}
return 0;
}