/// @return >0 for FD, -1 means error.
int CorosyncCpg::getFd() {
int fd = -1;
cs_error_t cs;
if (ready && handle != 0 && CS_OK != (cs = cpg_fd_get(handle, &fd))) {
LOG(ERROR)<< errorStr(cs, "Cannot get CPG file descriptor");
return -1;
}
return fd;
}
gboolean
cluster_connect_cpg(void)
{
cs_error_t rc;
unsigned int nodeid;
int fd;
int retries = 0;
static struct mainloop_fd_callbacks cpg_fd_callbacks =
{
.dispatch = pcmk_cpg_dispatch,
.destroy = cpg_connection_destroy,
};
strcpy(cpg_group.value, "pcmk");
cpg_group.length = strlen(cpg_group.value) + 1;
retries = 0;
cs_repeat(retries, 30, rc = cpg_initialize(&cpg_handle, &cpg_callbacks));
if (rc != CS_OK) {
crm_err("corosync cpg init error %d", rc);
return FALSE;
}
rc = cpg_fd_get(cpg_handle, &fd);
if (rc != CS_OK) {
crm_err("corosync cpg fd_get error %d", rc);
goto bail;
}
retries = 0;
cs_repeat(retries, 30, rc = cpg_local_get(cpg_handle, &nodeid));
if (rc != CS_OK) {
crm_err("corosync cpg local_get error %d", rc);
goto bail;
}
crm_debug("Our nodeid: %d", nodeid);
retries = 0;
cs_repeat(retries, 30, rc = cpg_join(cpg_handle, &cpg_group));
if (rc != CS_OK) {
crm_err("Could not join the CPG group '%s': %d", crm_system_name, rc);
goto bail;
}
mainloop_add_fd("corosync-cpg", G_PRIORITY_DEFAULT, fd, &cpg_handle, &cpg_fd_callbacks);
return TRUE;
bail:
cpg_finalize(cpg_handle);
return FALSE;
}
static PyObject *
py_cpg_fd_get(PyObject *self, PyObject *args)
{
int fd, ret;
cpg_handle_t handle;
PyObject *Phandle;
if (!PyArg_ParseTuple(args, "l", &handle))
return NULL;
ret = cpg_fd_get(handle, &fd);
RETURN_ON_ERROR(ret, "cpg_fd_get");
Phandle = PyInt_FromLong(fd);
return Phandle;
}
static void
test_cpg(void)
{
cpg_handle_t cpg_handle;
struct cpg_name group_name;
cs_error_t cs_res;
unsigned int local_nodeid;
int cpg_fd;
struct pollfd pfd;
int poll_res;
int state;
int cont;
ENTER();
state = 0;
strcpy(group_name.value, TEST_GROUP_NAME);
group_name.length = strlen(TEST_GROUP_NAME);
cs_repeat(cs_res = cpg_model_initialize(&cpg_handle, CPG_MODEL_V1,
(cpg_model_data_t *)&model_data, NULL));
assert(cs_res == CS_OK);
cs_repeat(cs_res = cpg_join(cpg_handle, &group_name));
assert(cs_res == CS_OK);
cs_repeat(cs_res = cpg_local_get(cpg_handle, &local_nodeid));
assert(cs_res == CS_OK);
assert(local_nodeid == TEST_NODEID);
cs_repeat(cs_res = cpg_fd_get(cpg_handle, &cpg_fd));
assert(cs_res == CS_OK);
cont = 1;
do {
pfd.fd = cpg_fd;
pfd.events = POLLIN;
pfd.revents = 0;
poll_res = poll(&pfd, 1, INFTIM);
if (poll_res == -1) {
perror("poll_res == -1");
}
assert(poll_res != 0);
assert(pfd.revents & POLLIN);
cs_repeat(cs_res = cpg_dispatch(cpg_handle, CS_DISPATCH_ALL));
assert(cs_res == CS_OK);
switch (state) {
case 0:
/*
* Waiting for cpg_confchg_received and cpg_totem_confchg_received
*/
if (cpg_confchg_received && cpg_totem_confchg_received) {
/*
* Send first message and wait for it in next state
*/
send_msg(cpg_handle);
state = 1;
}
break;
case 1:
if (received_msg_seq_no >= MESSAGES_TO_SENT) {
cont = 0;
} else if (received_msg_seq_no == sent_msg_seq_no) {
/*
* Message delivered so sent new one and wait for it
*/
send_msg(cpg_handle);
}
break;
}
} while (cont);
cs_repeat(cs_res = cpg_leave(cpg_handle, &group_name));
assert(cs_res == CS_OK);
cs_repeat(cs_res = cpg_finalize(cpg_handle));
assert(cs_res == CS_OK);
LEAVE();
}
gboolean
cluster_connect_cpg(crm_cluster_t *cluster)
{
int rc = -1;
int fd = 0;
int retries = 0;
uint32_t id = 0;
crm_node_t *peer = NULL;
cpg_handle_t handle = 0;
struct mainloop_fd_callbacks cpg_fd_callbacks = {
.dispatch = pcmk_cpg_dispatch,
.destroy = cluster->destroy,
};
cpg_callbacks_t cpg_callbacks = {
.cpg_deliver_fn = cluster->cpg.cpg_deliver_fn,
.cpg_confchg_fn = cluster->cpg.cpg_confchg_fn,
/* .cpg_deliver_fn = pcmk_cpg_deliver, */
/* .cpg_confchg_fn = pcmk_cpg_membership, */
};
cpg_evicted = FALSE;
cluster->group.length = 0;
cluster->group.value[0] = 0;
/* group.value is char[128] */
strncpy(cluster->group.value, crm_system_name?crm_system_name:"unknown", 127);
cluster->group.value[127] = 0;
cluster->group.length = 1 + QB_MIN(127, strlen(cluster->group.value));
cs_repeat(retries, 30, rc = cpg_initialize(&handle, &cpg_callbacks));
if (rc != CS_OK) {
crm_err("Could not connect to the Cluster Process Group API: %d", rc);
goto bail;
}
id = get_local_nodeid(handle);
if (id == 0) {
crm_err("Could not get local node id from the CPG API");
goto bail;
}
cluster->nodeid = id;
retries = 0;
cs_repeat(retries, 30, rc = cpg_join(handle, &cluster->group));
if (rc != CS_OK) {
crm_err("Could not join the CPG group '%s': %d", crm_system_name, rc);
goto bail;
}
rc = cpg_fd_get(handle, &fd);
if (rc != CS_OK) {
crm_err("Could not obtain the CPG API connection: %d", rc);
goto bail;
}
pcmk_cpg_handle = handle;
cluster->cpg_handle = handle;
mainloop_add_fd("corosync-cpg", G_PRIORITY_MEDIUM, fd, cluster, &cpg_fd_callbacks);
bail:
if (rc != CS_OK) {
cpg_finalize(handle);
return FALSE;
}
peer = crm_get_peer(id, NULL);
crm_update_peer_proc(__FUNCTION__, peer, crm_proc_cpg, ONLINESTATUS);
return TRUE;
}
gboolean
send_cluster_message_cs(xmlNode * msg, gboolean local, crm_node_t * node, enum crm_ais_msg_types dest)
{
gboolean rc = TRUE;
char *data = NULL;
data = dump_xml_unformatted(msg);
rc = send_cluster_text(crm_class_cluster, data, local, node, dest);
free(data);
return rc;
}
gboolean
send_cluster_text(int class, const char *data,
gboolean local, crm_node_t * node, enum crm_ais_msg_types dest)
{
static int msg_id = 0;
static int local_pid = 0;
static int local_name_len = 0;
static const char *local_name = NULL;
char *target = NULL;
struct iovec *iov;
AIS_Message *msg = NULL;
enum crm_ais_msg_types sender = text2msg_type(crm_system_name);
/* There are only 6 handlers registered to crm_lib_service in plugin.c */
CRM_CHECK(class < 6, crm_err("Invalid message class: %d", class);
return FALSE);
#if !SUPPORT_PLUGIN
CRM_CHECK(dest != crm_msg_ais, return FALSE);
#endif
if(local_name == NULL) {
local_name = get_local_node_name();
}
if(local_name_len == 0 && local_name) {
local_name_len = strlen(local_name);
}
if (data == NULL) {
data = "";
}
if (local_pid == 0) {
local_pid = getpid();
}
if (sender == crm_msg_none) {
sender = local_pid;
}
msg = calloc(1, sizeof(AIS_Message));
msg_id++;
msg->id = msg_id;
msg->header.id = class;
msg->header.error = CS_OK;
msg->host.type = dest;
msg->host.local = local;
if (node) {
if (node->uname) {
target = strdup(node->uname);
msg->host.size = strlen(node->uname);
memset(msg->host.uname, 0, MAX_NAME);
memcpy(msg->host.uname, node->uname, msg->host.size);
} else {
target = crm_strdup_printf("%u", node->id);
}
msg->host.id = node->id;
} else {
target = strdup("all");
}
msg->sender.id = 0;
msg->sender.type = sender;
msg->sender.pid = local_pid;
msg->sender.size = local_name_len;
memset(msg->sender.uname, 0, MAX_NAME);
if(local_name && msg->sender.size) {
memcpy(msg->sender.uname, local_name, msg->sender.size);
}
msg->size = 1 + strlen(data);
msg->header.size = sizeof(AIS_Message) + msg->size;
if (msg->size < CRM_BZ2_THRESHOLD) {
msg = realloc_safe(msg, msg->header.size);
memcpy(msg->data, data, msg->size);
} else {
char *compressed = NULL;
unsigned int new_size = 0;
char *uncompressed = strdup(data);
if (crm_compress_string(uncompressed, msg->size, 0, &compressed, &new_size)) {
msg->header.size = sizeof(AIS_Message) + new_size;
msg = realloc_safe(msg, msg->header.size);
memcpy(msg->data, compressed, new_size);
msg->is_compressed = TRUE;
msg->compressed_size = new_size;
} else {
msg = realloc_safe(msg, msg->header.size);
memcpy(msg->data, data, msg->size);
}
free(uncompressed);
free(compressed);
}
iov = calloc(1, sizeof(struct iovec));
iov->iov_base = msg;
iov->iov_len = msg->header.size;
if (msg->compressed_size) {
crm_trace("Queueing CPG message %u to %s (%llu bytes, %d bytes compressed payload): %.200s",
msg->id, target, (unsigned long long) iov->iov_len,
msg->compressed_size, data);
} else {
crm_trace("Queueing CPG message %u to %s (%llu bytes, %d bytes payload): %.200s",
msg->id, target, (unsigned long long) iov->iov_len,
msg->size, data);
}
free(target);
#if SUPPORT_PLUGIN
/* The plugin is the only time we dont use CPG messaging */
if(get_cluster_type() == pcmk_cluster_classic_ais) {
return send_plugin_text(class, iov);
}
#endif
send_cpg_iov(iov);
return TRUE;
}
enum crm_ais_msg_types
text2msg_type(const char *text)
{
int type = crm_msg_none;
CRM_CHECK(text != NULL, return type);
if (safe_str_eq(text, "ais")) {
type = crm_msg_ais;
} else if (safe_str_eq(text, "crm_plugin")) {
type = crm_msg_ais;
} else if (safe_str_eq(text, CRM_SYSTEM_CIB)) {
type = crm_msg_cib;
} else if (safe_str_eq(text, CRM_SYSTEM_CRMD)) {
type = crm_msg_crmd;
} else if (safe_str_eq(text, CRM_SYSTEM_DC)) {
type = crm_msg_crmd;
} else if (safe_str_eq(text, CRM_SYSTEM_TENGINE)) {
type = crm_msg_te;
} else if (safe_str_eq(text, CRM_SYSTEM_PENGINE)) {
type = crm_msg_pe;
} else if (safe_str_eq(text, CRM_SYSTEM_LRMD)) {
type = crm_msg_lrmd;
} else if (safe_str_eq(text, CRM_SYSTEM_STONITHD)) {
type = crm_msg_stonithd;
} else if (safe_str_eq(text, "stonith-ng")) {
type = crm_msg_stonith_ng;
} else if (safe_str_eq(text, "attrd")) {
type = crm_msg_attrd;
} else {
/* This will normally be a transient client rather than
* a cluster daemon. Set the type to the pid of the client
*/
int scan_rc = sscanf(text, "%d", &type);
if (scan_rc != 1 || type <= crm_msg_stonith_ng) {
/* Ensure it's sane */
type = crm_msg_none;
}
}
return type;
}
static void do_command (int sock, char* func, char*args[], int num_args)
{
int result;
char response[100];
struct cpg_name group_name;
ssize_t rc;
size_t send_len;
qb_log (LOG_TRACE, "RPC:%s() called.", func);
if (strcmp ("cpg_mcast_joined",func) == 0) {
struct iovec iov[5];
int a;
for (a = 0; a < num_args; a++) {
iov[a].iov_base = args[a];
iov[a].iov_len = strlen(args[a])+1;
}
cpg_mcast_joined (cpg_handle, CPG_TYPE_AGREED, iov, num_args);
} else if (strcmp ("cpg_join",func) == 0) {
if (strlen(args[0]) >= CPG_MAX_NAME_LENGTH) {
qb_log (LOG_ERR, "Invalid group name");
exit (1);
}
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_join (cpg_handle, &group_name);
if (result != CS_OK) {
qb_log (LOG_ERR,
"Could not join process group, error %d", result);
exit (1);
}
qb_log (LOG_INFO, "called cpg_join(%s)!", group_name.value);
} else if (strcmp ("cpg_leave",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_leave (cpg_handle, &group_name);
if (result != CS_OK) {
qb_log (LOG_ERR,
"Could not leave process group, error %d", result);
exit (1);
}
qb_log (LOG_INFO, "called cpg_leave(%s)!", group_name.value);
} else if (strcmp ("cpg_initialize",func) == 0) {
int retry_count = 0;
result = cpg_initialize (&cpg_handle, &callbacks);
while (result != CS_OK) {
qb_log (LOG_ERR,
"cpg_initialize error %d (attempt %d)",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = cpg_initialize (&cpg_handle, &callbacks);
}
cpg_fd_get (cpg_handle, &cpg_fd);
qb_loop_poll_add (ta_poll_handle_get(),
QB_LOOP_MED,
cpg_fd,
POLLIN|POLLNVAL,
NULL,
cpg_dispatch_wrapper_fn);
} else if (strcmp ("cpg_local_get", func) == 0) {
unsigned int local_nodeid;
cpg_local_get (cpg_handle, &local_nodeid);
snprintf (response, 100, "%u",local_nodeid);
send_len = strlen (response);
rc = send (sock, response, send_len, 0);
assert(rc == send_len);
} else if (strcmp ("cpg_finalize", func) == 0) {
if (cpg_handle > 0) {
cpg_finalize (cpg_handle);
cpg_handle = 0;
}
} else if (strcmp ("record_config_events", func) == 0) {
record_config_events (sock);
} else if (strcmp ("record_messages", func) == 0) {
record_messages ();
} else if (strcmp ("read_config_event", func) == 0) {
read_config_event (sock);
} else if (strcmp ("read_messages", func) == 0) {
read_messages (sock, args[0]);
} else if (strcmp ("msg_blaster_zcb", func) == 0) {
msg_blaster_zcb (sock, args[0]);
} else if (strcmp ("pcmk_test", func) == 0) {
pcmk_test = 1;
} else if (strcmp ("msg_blaster", func) == 0) {
msg_blaster (sock, args[0]);
} else if (strcmp ("context_test", func) == 0) {
context_test (sock);
} else if (strcmp ("are_you_ok_dude", func) == 0) {
snprintf (response, 100, "%s", OK_STR);
send_len = strlen (response);
rc = send (sock, response, strlen (response), 0);
assert(rc == send_len);
} else if (strcmp ("cfg_shutdown", func) == 0) {
qb_log (LOG_INFO, "calling %s() called!", func);
result = corosync_cfg_try_shutdown (cfg_handle, COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST);
qb_log (LOG_INFO,"%s() returned %d!", func, result);
} else if (strcmp ("cfg_initialize",func) == 0) {
int retry_count = 0;
qb_log (LOG_INFO,"%s() called!", func);
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
while (result != CS_OK) {
qb_log (LOG_ERR,
"cfg_initialize error %d (attempt %d)",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
}
qb_log (LOG_INFO,"corosync_cfg_initialize() == %d", result);
result = corosync_cfg_fd_get (cfg_handle, &cfg_fd);
qb_log (LOG_INFO,"corosync_cfg_fd_get() == %d", result);
qb_loop_poll_add (ta_poll_handle_get(),
QB_LOOP_MED,
cfg_fd,
POLLIN|POLLNVAL,
NULL,
cfg_dispatch_wrapper_fn);
} else {
qb_log(LOG_ERR, "RPC:%s not supported!", func);
}
}
int main (int argc, char *argv[]) {
cpg_handle_t handle;
fd_set read_fds;
int select_fd;
int result;
const char *options = "i";
int opt;
unsigned int nodeid;
char *fgets_res;
while ( (opt = getopt(argc, argv, options)) != -1 ) {
switch (opt) {
case 'i':
show_ip = 1;
break;
}
}
if (argc > optind) {
strcpy(group_name.value, argv[optind]);
group_name.length = strlen(argv[optind]);
}
else {
strcpy(group_name.value, "GROUP");
group_name.length = 6;
}
result = cpg_initialize (&handle, &callbacks);
if (result != CS_OK) {
printf ("Could not initialize Cluster Process Group API instance error %d\n", result);
exit (1);
}
result = cpg_local_get (handle, &nodeid);
if (result != CS_OK) {
printf ("Could not get local node id\n");
exit (1);
}
printf ("Local node id is %x\n", nodeid);
result = cpg_join(handle, &group_name);
if (result != CS_OK) {
printf ("Could not join process group, error %d\n", result);
exit (1);
}
FD_ZERO (&read_fds);
cpg_fd_get(handle, &select_fd);
printf ("Type EXIT to finish\n");
do {
FD_SET (select_fd, &read_fds);
FD_SET (STDIN_FILENO, &read_fds);
result = select (select_fd + 1, &read_fds, 0, 0, 0);
if (result == -1) {
perror ("select\n");
}
if (FD_ISSET (STDIN_FILENO, &read_fds)) {
char inbuf[132];
struct iovec iov;
fgets_res = fgets(inbuf, sizeof(inbuf), stdin);
if (fgets_res == NULL) {
cpg_leave(handle, &group_name);
}
if (strncmp(inbuf, "EXIT", 4) == 0) {
cpg_leave(handle, &group_name);
}
else {
iov.iov_base = inbuf;
iov.iov_len = strlen(inbuf)+1;
cpg_mcast_joined(handle, CPG_TYPE_AGREED, &iov, 1);
}
}
if (FD_ISSET (select_fd, &read_fds)) {
if (cpg_dispatch (handle, CS_DISPATCH_ALL) != CS_OK)
exit(1);
}
} while (result && !quit);
result = cpg_finalize (handle);
printf ("Finalize result is %d (should be 1)\n", result);
return (0);
}
int main (int argc, char *argv[]) {
cpg_handle_t handle;
fd_set read_fds;
int select_fd;
int result;
int retries;
const char *options = "i";
int opt;
unsigned int nodeid;
char *fgets_res;
struct cpg_address member_list[64];
int member_list_entries;
int i;
int recnt;
int doexit;
const char *exitStr = "EXIT";
doexit = 0;
#ifdef QBLOG
qb_log_init("testcpg", LOG_USER, LOG_ERR);
qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
QB_LOG_FILTER_FILE, "*", LOG_TRACE);
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
qb_log_format_set(QB_LOG_STDERR, "[%p] %f %b");
#endif
while ( (opt = getopt(argc, argv, options)) != -1 ) {
switch (opt) {
case 'i':
show_ip = 1;
break;
}
}
if (argc > optind) {
strcpy(group_name.value, argv[optind]);
group_name.length = strlen(argv[optind]);
}
else {
strcpy(group_name.value, "GROUP");
group_name.length = 6;
}
recnt = 0;
printf ("Type %s to finish\n", exitStr);
restart = 1;
do {
if(restart) {
restart = 0;
retries = 0;
cs_repeat_init(retries, 30, result = cpg_model_initialize (&handle, CPG_MODEL_V1, (cpg_model_data_t *)&model_data, NULL));
if (result != CS_OK) {
printf ("Could not initialize Cluster Process Group API instance error %d\n", result);
retrybackoff(recnt);
}
retries = 0;
cs_repeat(retries, 30, result = cpg_local_get(handle, &nodeid));
if (result != CS_OK) {
printf ("Could not get local node id\n");
retrybackoff(recnt);
}
printf ("Local node id is %x\n", nodeid);
nodeidStart = nodeid;
retries = 0;
cs_repeat(retries, 30, result = cpg_join(handle, &group_name));
if (result != CS_OK) {
printf ("Could not join process group, error %d\n", result);
retrybackoff(recnt);
}
retries = 0;
cs_repeat(retries, 30, result = cpg_membership_get (handle, &group_name,
(struct cpg_address *)&member_list, &member_list_entries));
if (result != CS_OK) {
printf ("Could not get current membership list %d\n", result);
retrybackoff(recnt);
}
recnt = 0;
printf ("membership list\n");
for (i = 0; i < member_list_entries; i++) {
printf ("node id %d pid %d\n", member_list[i].nodeid,
member_list[i].pid);
}
FD_ZERO (&read_fds);
cpg_fd_get(handle, &select_fd);
}
FD_SET (select_fd, &read_fds);
FD_SET (STDIN_FILENO, &read_fds);
result = select (select_fd + 1, &read_fds, 0, 0, 0);
if (result == -1) {
perror ("select\n");
}
if (FD_ISSET (STDIN_FILENO, &read_fds)) {
char inbuf[132];
struct iovec iov;
fgets_res = fgets(inbuf, (int)sizeof(inbuf), stdin);
if (fgets_res == NULL) {
doexit = 1;
cpg_leave(handle, &group_name);
}
if (strncmp(inbuf, exitStr, strlen(exitStr)) == 0) {
doexit = 1;
cpg_leave(handle, &group_name);
}
else {
iov.iov_base = inbuf;
iov.iov_len = strlen(inbuf)+1;
cpg_mcast_joined(handle, CPG_TYPE_AGREED, &iov, 1);
}
}
if (FD_ISSET (select_fd, &read_fds)) {
if (cpg_dispatch (handle, CS_DISPATCH_ALL) != CS_OK) {
if(doexit) {
exit(1);
}
restart = 1;
}
}
if(restart) {
if(!doexit) {
result = cpg_finalize (handle);
printf ("Finalize+restart result is %d (should be 1)\n", result);
continue;
}
}
} while (result && !quit && !doexit);
result = cpg_finalize (handle);
printf ("Finalize result is %d (should be 1)\n", result);
return (0);
}
static void do_command (int sock, char* func, char*args[], int num_args)
{
int result;
char response[100];
struct cpg_name group_name;
if (parse_debug)
syslog (LOG_DEBUG,"RPC:%s() called.", func);
if (strcmp ("cpg_mcast_joined",func) == 0) {
struct iovec iov[5];
int a;
for (a = 0; a < num_args; a++) {
iov[a].iov_base = args[a];
iov[a].iov_len = strlen(args[a])+1;
}
cpg_mcast_joined (cpg_handle, CPG_TYPE_AGREED, iov, num_args);
} else if (strcmp ("cpg_join",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_join (cpg_handle, &group_name);
if (result != CS_OK) {
syslog (LOG_ERR,
"Could not join process group, error %d\n", result);
exit (1);
}
syslog (LOG_INFO, "called cpg_join()!");
} else if (strcmp ("cpg_leave",func) == 0) {
strcpy (group_name.value, args[0]);
group_name.length = strlen(args[0]);
result = cpg_leave (cpg_handle, &group_name);
if (result != CS_OK) {
syslog (LOG_ERR,
"Could not leave process group, error %d\n", result);
exit (1);
}
syslog (LOG_INFO, "called cpg_leave()!");
} else if (strcmp ("cpg_initialize",func) == 0) {
int retry_count = 0;
result = cpg_initialize (&cpg_handle, &callbacks);
while (result != CS_OK) {
syslog (LOG_ERR,
"cpg_initialize error %d (attempt %d)\n",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = cpg_initialize (&cpg_handle, &callbacks);
}
cpg_fd_get (cpg_handle, &cpg_fd);
poll_dispatch_add (ta_poll_handle_get(), cpg_fd, POLLIN|POLLNVAL, NULL, cpg_dispatch_wrapper_fn);
} else if (strcmp ("cpg_local_get", func) == 0) {
unsigned int local_nodeid;
cpg_local_get (cpg_handle, &local_nodeid);
snprintf (response, 100, "%u",local_nodeid);
send (sock, response, strlen (response), 0);
} else if (strcmp ("cpg_finalize", func) == 0) {
cpg_finalize (cpg_handle);
poll_dispatch_delete (ta_poll_handle_get(), cpg_fd);
cpg_fd = -1;
} else if (strcmp ("record_config_events", func) == 0) {
record_config_events (sock);
} else if (strcmp ("record_messages", func) == 0) {
record_messages ();
} else if (strcmp ("read_config_event", func) == 0) {
read_config_event (sock);
} else if (strcmp ("read_messages", func) == 0) {
read_messages (sock, args[0]);
} else if (strcmp ("msg_blaster_zcb", func) == 0) {
msg_blaster_zcb (sock, args[0]);
} else if (strcmp ("pcmk_test", func) == 0) {
pcmk_test = 1;
} else if (strcmp ("msg_blaster", func) == 0) {
msg_blaster (sock, args[0]);
} else if (strcmp ("context_test", func) == 0) {
context_test (sock);
} else if (strcmp ("are_you_ok_dude", func) == 0) {
snprintf (response, 100, "%s", OK_STR);
send (sock, response, strlen (response), 0);
} else if (strcmp ("cfg_shutdown", func) == 0) {
corosync_cfg_try_shutdown (cfg_handle, COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST);
} else if (strcmp ("cfg_initialize",func) == 0) {
int retry_count = 0;
syslog (LOG_INFO,"%s %s() called!", __func__, func);
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
while (result != CS_OK) {
syslog (LOG_ERR,
"cfg_initialize error %d (attempt %d)\n",
result, retry_count);
if (retry_count >= 3) {
exit (1);
}
sleep(1);
retry_count++;
result = corosync_cfg_initialize (&cfg_handle, &cfg_callbacks);
}
corosync_cfg_fd_get (cfg_handle, &cfg_fd);
corosync_cfg_state_track (cfg_handle, 0, ¬ification_buffer);
poll_dispatch_add (ta_poll_handle_get(), cfg_fd, POLLIN|POLLNVAL, NULL, cfg_dispatch_wrapper_fn);
} else {
syslog (LOG_ERR,"%s RPC:%s not supported!", __func__, func);
}
}
