void
mon_update(const HA_Message *msg, int call_id, int rc,
crm_data_t *output, void*user_data)
{
const char *prefix = NULL;
if(rc == cib_ok) {
crm_data_t *cib = NULL;
#if CRM_DEPRECATED_SINCE_2_0_4
if( safe_str_eq(crm_element_name(output), XML_TAG_CIB) ) {
cib = output;
} else {
cib = find_xml_node(output,XML_TAG_CIB,TRUE);
}
#else
cib = output;
CRM_DEV_ASSERT(safe_str_eq(crm_element_name(cib), XML_TAG_CIB));
#endif
if(as_html_file || web_cgi) {
print_html_status(cib, as_html_file, web_cgi);
} else if (simple_status) {
print_simple_status(cib);
if (has_warnings) {
exit(1);
}
} else {
print_status(cib);
}
if(one_shot) {
exit(LSB_EXIT_OK);
}
} else if(simple_status) {
fprintf(stderr, "Critical: query failed: %s", cib_error2string(rc));
exit(2);
} else if(one_shot) {
fprintf(stderr, "Query failed: %s", cib_error2string(rc));
exit(LSB_EXIT_OK);
} else {
CRM_DEV_ASSERT(cib_conn->cmds->signoff(cib_conn) == cib_ok);
crm_err("Query failed: %s", cib_error2string(rc));
prefix = "Query failed! ";
}
wait_for_refresh(0, prefix, interval);
}
static void
revision_check_callback(const HA_Message *msg, int call_id, int rc,
crm_data_t *output, void *user_data)
{
int cmp = -1;
const char *revision = NULL;
crm_data_t *generation = NULL;
#if CRM_DEPRECATED_SINCE_2_0_4
if(safe_str_eq(crm_element_name(output), XML_TAG_CIB)) {
generation = output;
} else {
generation = find_xml_node(output, XML_TAG_CIB, TRUE);
}
#else
generation = output;
CRM_DEV_ASSERT(safe_str_eq(crm_element_name(generation), XML_TAG_CIB));
#endif
if(rc != cib_ok) {
fsa_data_t *msg_data = NULL;
register_fsa_error(C_FSA_INTERNAL, I_ERROR, NULL);
return;
}
crm_debug_3("Checking our feature revision is allowed: %s",
CIB_FEATURE_SET);
revision = crm_element_value(generation, XML_ATTR_CIB_REVISION);
cmp = compare_version(revision, CIB_FEATURE_SET);
if(cmp > 0) {
crm_err("This build (%s) does not support the current"
" resource configuration", VERSION);
crm_err("We can support up to CIB feature set %s (current=%s)",
CIB_FEATURE_SET, revision);
crm_err("Shutting down the CRM");
/* go into a stall state */
register_fsa_error_adv(
C_FSA_INTERNAL, I_SHUTDOWN, NULL, NULL, __FUNCTION__);
return;
}
revision = crm_element_value(generation, XML_ATTR_CRM_VERSION);
cmp = compare_version(revision, CRM_FEATURE_SET);
if(cmp > 0) {
crm_err("This build (%s) does not support the current"
" resource configuration", VERSION);
crm_err("We can support up to CRM feature set %s (current=%s)",
revision, CRM_FEATURE_SET);
crm_err("Shutting down the CRM");
/* go into a stall state */
register_fsa_error_adv(
C_FSA_INTERNAL, I_SHUTDOWN, NULL, NULL, __FUNCTION__);
return;
}
}
/*
CIBへのsync_from処理のコールバック処理
CRM_OP_JOIN_ACKNAKメッセージを送信する
*/
void
finalize_sync_callback(xmlNode *msg, int call_id, int rc,
xmlNode *output, void *user_data)
{
CRM_DEV_ASSERT(cib_not_master != rc);
clear_bit_inplace(fsa_input_register, R_CIB_ASKED);
if(rc != cib_ok) {
do_crm_log((rc==cib_old_data?LOG_WARNING:LOG_ERR),
"Sync from %s resulted in an error: %s",
(char*)user_data, cib_error2string(rc));
/* restart the whole join process */
/* コールバックがcib_okではない場合は、I_ELECTION_DCに戻る */
register_fsa_error_adv(
C_FSA_INTERNAL, I_ELECTION_DC,NULL,NULL,__FUNCTION__);
} else if(AM_I_DC && fsa_state == S_FINALIZE_JOIN) {
/* 自ノードがDCノードで、fsa_stateがS_FINALIZE_JOINの場合 */
set_bit_inplace(fsa_input_register, R_HAVE_CIB);
clear_bit_inplace(fsa_input_register, R_CIB_ASKED);
/* make sure dc_uuid is re-set to us */
/* JOIN状態チェック処理 */
if(check_join_state(fsa_state, __FUNCTION__) == FALSE) {
crm_debug("Notifying %d clients of join-%d results",
g_hash_table_size(integrated_nodes), current_join_id);
/*
ノードをCIBのnodeエントリに追加して、CRM_OP_JOIN_ACKNAKメッセージを送信する
また、クラスタメンバーとして認識したノードは、finalized_nodesハッシュテーブルに追加する
そして、integrated_nodesハッシュテーブルから削除する
*/
g_hash_table_foreach_remove(
integrated_nodes, finalize_join_for, NULL);
}
} else {
crm_debug("No longer the DC in S_FINALIZE_JOIN: %s/%s",
AM_I_DC?"DC":"CRMd", fsa_state2string(fsa_state));
}
crm_free(user_data);
}
void
cib_notify_client(gpointer key, gpointer value, gpointer user_data)
{
IPC_Channel *ipc_client = NULL;
HA_Message *update_msg = user_data;
cib_client_t *client = value;
const char *type = NULL;
gboolean is_pre = FALSE;
gboolean is_post = FALSE;
gboolean is_confirm = FALSE;
gboolean is_replace = FALSE;
gboolean is_diff = FALSE;
gboolean do_send = FALSE;
int qlen = 0;
int max_qlen = 0;
CRM_DEV_ASSERT(client != NULL);
CRM_DEV_ASSERT(update_msg != NULL);
type = cl_get_string(update_msg, F_SUBTYPE);
CRM_DEV_ASSERT(type != NULL);
if(client == NULL) {
crm_warn("Skipping NULL client");
return;
} else if(client->channel == NULL) {
crm_warn("Skipping client with NULL channel");
return;
} else if(client->name == NULL) {
crm_debug_2("Skipping unnammed client / comamnd channel");
return;
}
if(safe_str_eq(type, T_CIB_PRE_NOTIFY)) {
is_pre = TRUE;
} else if(safe_str_eq(type, T_CIB_POST_NOTIFY)) {
is_post = TRUE;
} else if(safe_str_eq(type, T_CIB_UPDATE_CONFIRM)) {
is_confirm = TRUE;
} else if(safe_str_eq(type, T_CIB_DIFF_NOTIFY)) {
is_diff = TRUE;
} else if(safe_str_eq(type, T_CIB_REPLACE_NOTIFY)) {
is_replace = TRUE;
}
ipc_client = client->channel;
qlen = ipc_client->send_queue->current_qlen;
max_qlen = ipc_client->send_queue->max_qlen;
#if 1
/* get_chan_status() causes memory to be allocated that isnt free'd
* until the message is read (which messes up the memory stats)
*/
if(ipc_client->ops->get_chan_status(ipc_client) != IPC_CONNECT) {
crm_debug_2("Skipping notification to disconnected"
" client %s/%s", client->name, client->id);
} else if(client->pre_notify && is_pre) {
if(qlen < (int)(0.4 * max_qlen)) {
do_send = TRUE;
} else {
crm_warn("Throttling pre-notifications due to"
" high load: queue=%d (max=%d)",
qlen, max_qlen);
}
} else if(client->post_notify && is_post) {
if(qlen < (int)(0.7 * max_qlen)) {
do_send = TRUE;
} else {
crm_warn("Throttling post-notifications due to"
" extreme load: queue=%d (max=%d)",
qlen, max_qlen);
}
/* these are critical */
} else
#endif
if(client->diffs && is_diff) {
do_send = TRUE;
} else if(client->confirmations && is_confirm) {
do_send = TRUE;
} else if(client->replace && is_replace) {
do_send = TRUE;
}
if(do_send) {
crm_debug_2("Notifying client %s/%s of %s update (queue=%d)",
client->name, client->channel_name, type, qlen);
if(ipc_client->send_queue->current_qlen >= ipc_client->send_queue->max_qlen) {
/* We never want the CIB to exit because our client is slow */
crm_crit("%s-notification of client %s/%s failed - queue saturated",
is_confirm?"Confirmation":is_post?"Post":"Pre",
client->name, client->id);
} else if(send_ipc_message(ipc_client, update_msg) == FALSE) {
crm_warn("Notification of client %s/%s failed",
client->name, client->id);
}
} else {
crm_debug_3("Client %s/%s not interested in %s notifications",
client->name, client->channel_name, type);
}
}
int
main(int argc, char **argv)
{
cib_t * the_cib = NULL;
enum cib_errors rc = cib_ok;
int cib_opts = cib_sync_call;
int argerr = 0;
int flag;
int option_index = 0;
crm_system_name = basename(argv[0]);
crm_set_options("V?$GDQqN:U:u:s:n:v:l:t:i:!r:d:", "command -n attribute [options]", long_options,
"Manage node's attributes and cluster options."
"\n\nAllows node attributes and cluster options to be queried, modified and deleted.\n");
if(argc < 2) {
crm_help('?', LSB_EXIT_EINVAL);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch(flag) {
case 'V':
cl_log_enable_stderr(TRUE);
alter_debug(DEBUG_INC);
break;
case '$':
case '?':
crm_help(flag, LSB_EXIT_OK);
break;
case 'D':
case 'G':
case 'v':
command = flag;
attr_value = optarg;
break;
case 'q':
case 'Q':
BE_QUIET = TRUE;
break;
case 'U':
case 'N':
dest_uname = crm_strdup(optarg);
break;
case 'u':
dest_node = crm_strdup(optarg);
break;
case 's':
set_name = crm_strdup(optarg);
break;
case 'l':
case 't':
type = optarg;
break;
case 'n':
attr_name = crm_strdup(optarg);
break;
case 'i':
attr_id = crm_strdup(optarg);
break;
case 'r':
rsc_id = optarg;
break;
case 'd':
attr_default = optarg;
break;
case '!':
crm_warn("Inhibiting notifications for this update");
cib_opts |= cib_inhibit_notify;
break;
default:
printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if(BE_QUIET == FALSE) {
crm_log_init(basename(argv[0]), LOG_ERR, FALSE, FALSE, argc, argv);
} else {
crm_log_init(basename(argv[0]), LOG_ERR, FALSE, FALSE, 0, NULL);
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
crm_help('?', LSB_EXIT_GENERIC);
}
the_cib = cib_new();
rc = the_cib->cmds->signon(the_cib, crm_system_name, cib_command);
if(rc != cib_ok) {
fprintf(stderr, "Error signing on to the CIB service: %s\n", cib_error2string(rc));
return rc;
}
if(safe_str_eq(type, "reboot")) {
type = XML_CIB_TAG_STATUS;
} else if(safe_str_eq(type, "forever")) {
type = XML_CIB_TAG_NODES;
}
if(type == NULL && dest_uname == NULL) {
/* we're updating cluster options - dont populate dest_node */
type = XML_CIB_TAG_CRMCONFIG;
} else {
determine_host(the_cib, &dest_uname, &dest_node);
}
if(rc != cib_ok) {
crm_info("Error during setup of %s=%s update", attr_name, command=='D'?"<none>":attr_value);
} else if( (command=='v' || command=='D')
&& safe_str_eq(type, XML_CIB_TAG_STATUS)
&& attrd_lazy_update(command, dest_uname, attr_name, attr_value, type, set_name, NULL)) {
crm_info("Update %s=%s sent via attrd", attr_name, command=='D'?"<none>":attr_value);
} else if(command=='D') {
rc = delete_attr(the_cib, cib_opts, type, dest_node, set_name,
attr_id, attr_name, attr_value, TRUE);
if(rc == cib_NOTEXISTS) {
/* Nothing to delete...
* which means its not there...
* which is what the admin wanted
*/
rc = cib_ok;
} else if(rc != cib_missing_data
&& safe_str_eq(crm_system_name, "crm_failcount")) {
char *now_s = NULL;
time_t now = time(NULL);
now_s = crm_itoa(now);
update_attr(the_cib, cib_sync_call,
XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL,
"last-lrm-refresh", now_s, TRUE);
crm_free(now_s);
}
} else if(command=='v') {
CRM_DEV_ASSERT(type != NULL);
CRM_DEV_ASSERT(attr_name != NULL);
CRM_DEV_ASSERT(attr_value != NULL);
rc = update_attr(the_cib, cib_opts, type, dest_node, set_name,
attr_id, attr_name, attr_value, TRUE);
} else /* query */ {
char *read_value = NULL;
rc = read_attr(the_cib, type, dest_node, set_name,
attr_id, attr_name, &read_value, TRUE);
if(rc == cib_NOTEXISTS && attr_default) {
read_value = crm_strdup(attr_default);
rc = cib_ok;
}
crm_info("Read %s=%s %s%s",
attr_name, crm_str(read_value),
set_name?"in ":"", set_name?set_name:"");
if(rc == cib_missing_data) {
rc = cib_ok;
} else if(BE_QUIET == FALSE) {
fprintf(stdout, "%s%s %s%s %s%s value=%s\n",
type?"scope=":"", type?type:"",
attr_id?"id=":"", attr_id?attr_id:"",
attr_name?"name=":"", attr_name?attr_name:"",
read_value?read_value:"(null)");
} else if(read_value != NULL) {
fprintf(stdout, "%s\n", read_value);
}
}
the_cib->cmds->signoff(the_cib);
if(rc == cib_missing_data) {
printf("Please choose from one of the matches above and suppy the 'id' with --attr-id\n");
} else if(rc != cib_ok) {
fprintf(stderr, "Error performing operation: %s\n",
cib_error2string(rc));
}
return rc;
}
gboolean
mon_timer_popped(gpointer data)
{
int rc = cib_ok;
int options = cib_scope_local;
if(timer_id > 0) {
Gmain_timeout_remove(timer_id);
}
if(as_console) {
#if CURSES_ENABLED
move(0, 0);
printw("Updating...\n");
clrtoeol();
refresh();
#endif
} else {
crm_notice("Updating...");
}
if(cib_conn == NULL) {
crm_debug_4("Creating CIB connection");
cib_conn = cib_new();
}
CRM_DEV_ASSERT(cib_conn != NULL);
if(crm_assert_failed) {
return FALSE;
} else if(cib_conn->state != cib_connected_query){
crm_debug_4("Connecting to the CIB");
#if CURSES_ENABLED
if(as_console) {
printw("Signing on...\n");
clrtoeol();
refresh();
}
#endif
if(cib_ok == cib_conn->cmds->signon(
cib_conn, crm_system_name, cib_query)) {
failed_connections = 0;
} else if (simple_status || one_shot) {
fprintf(stdout, "Critical: Unable to connect to the CIB\n");
exit(2);
} else {
failed_connections++;
CRM_DEV_ASSERT(cib_conn->cmds->signoff(cib_conn) == cib_ok);
wait_for_refresh(0, "Not connected: ", 2*interval);
return FALSE;
}
#if CURSES_ENABLED
if(as_console) {
printw("Querying...\n");
clrtoeol();
refresh();
}
#endif
}
if(as_console) { blank_screen(); }
rc = cib_conn->cmds->query(cib_conn, NULL, NULL, options);
add_cib_op_callback(rc, FALSE, NULL, mon_update);
return FALSE;
}
