ccm.c

linux集群服务器软件代码包

				member->node_uname =
					crm_strdup(oc->m_array[offset+lpc].node_uname);
			} else {
				crm_err("Node %d had a NULL uname",
					member->node_id);
			}
			g_hash_table_insert(
				members, member->node_uname, member);	
		}
		
	} else {
		membership_copy->members = NULL;
	}
	
	crm_devel("Copying new members");

	/*--*-- New Member Nodes --*--*/
	offset = oc->m_in_idx;
	membership_copy->new_members_size = oc->m_n_in;

	if(membership_copy->new_members_size > 0) {
		membership_copy->new_members =
			g_hash_table_new(g_str_hash, g_str_equal);
		members = membership_copy->new_members;
		
		for(lpc=0; lpc < membership_copy->new_members_size; lpc++) {
			oc_node_t *member = NULL;
			crm_malloc(member, sizeof(oc_node_t));

			if(member == NULL) {
				continue;
			}
			
			member->node_uname = NULL;
			member->node_id = oc->m_array[offset+lpc].node_id;
			member->node_born_on =
				oc->m_array[offset+lpc].node_born_on;

			if(oc->m_array[offset+lpc].node_uname != NULL) {
				member->node_uname =
					crm_strdup(oc->m_array[offset+lpc].node_uname);
			} else {
				crm_err("Node %d had a NULL uname",
					member->node_id);
			}
			g_hash_table_insert(
				members, member->node_uname, member);	

			g_hash_table_insert(members, member->node_uname, member);
		}

	} else {
		membership_copy->new_members = NULL;
	}
	
	crm_devel("Copying dead members");

	/*--*-- Recently Dead Member Nodes --*--*/
	offset = oc->m_out_idx;
	membership_copy->dead_members_size = oc->m_n_out;
	if(membership_copy->dead_members_size > 0) {
		membership_copy->dead_members =
			g_hash_table_new(g_str_hash, g_str_equal);

		members = membership_copy->dead_members;

		for(lpc=0; lpc < membership_copy->dead_members_size; lpc++) {
			oc_node_t *member = NULL;
			crm_malloc(member, sizeof(oc_node_t));

			if(member == NULL) {
				continue;
			}
			
			member->node_id =
				oc->m_array[offset+lpc].node_id;
			
			member->node_born_on =
				oc->m_array[offset+lpc].node_born_on;
			
			member->node_uname = NULL;
			if(oc->m_array[offset+lpc].node_uname != NULL) {
				member->node_uname =
					crm_strdup(oc->m_array[offset+lpc].node_uname);
			} else {
				crm_err("Node %d had a NULL uname",
					member->node_id);
			}
			g_hash_table_insert(
				members, member->node_uname, member);	

			g_hash_table_insert(members, member->node_uname, member);
		}

	} else {
		membership_copy->dead_members = NULL;
	}

	crm_devel("Replacing old copies");
	tmp = fsa_membership_copy;
	fsa_membership_copy = membership_copy;

	/* Free the old copy */
	if(tmp != NULL) {
		if(tmp->members != NULL)
			g_hash_table_foreach_remove(
				tmp->members, ghash_node_clfree, NULL);
		if(tmp->new_members != NULL)
			g_hash_table_foreach_remove(
				tmp->new_members, ghash_node_clfree, NULL);
		if(tmp->dead_members != NULL)
			g_hash_table_foreach_remove(
				tmp->dead_members, ghash_node_clfree, NULL);
		crm_free(tmp);
	}
	crm_devel("Free'd old copies");

	if(AM_I_DC) {
		/* should be sufficient for only the DC to do this */
		crm_data_t *foo = NULL;
		crm_devel("Updating the CIB");
		foo = do_update_cib_nodes(NULL, FALSE);
		free_xml(foo);
	}
	
	set_bit_inplace(fsa_input_register, R_CCM_DATA);
	
	return next_input;
}

void
ccm_event_detail(const oc_ev_membership_t *oc, oc_ed_t event)
{
	int member_id = -1;
	gboolean member = FALSE;
	int lpc;
	int node_list_size;

	crm_info("-----------------------");
	crm_debug("trans=%d, nodes=%d, new=%d, lost=%d n_idx=%d, "
	       "new_idx=%d, old_idx=%d",
	       oc->m_instance,
	       oc->m_n_member,
	       oc->m_n_in,
	       oc->m_n_out,
	       oc->m_memb_idx,
	       oc->m_in_idx,
	       oc->m_out_idx);
	
	node_list_size = oc->m_n_member;
	for(lpc=0; lpc<node_list_size; lpc++) {
		crm_info("\tCURRENT: %s [nodeid=%d, born=%d]",
		       oc->m_array[oc->m_memb_idx+lpc].node_uname,
		       oc->m_array[oc->m_memb_idx+lpc].node_id,
		       oc->m_array[oc->m_memb_idx+lpc].node_born_on);

		if(safe_str_eq(fsa_our_uname,
			       oc->m_array[oc->m_memb_idx+lpc].node_uname)) {
			member = TRUE;
			member_id = oc->m_array[oc->m_memb_idx+lpc].node_id;
		}
	}
	
	if (member == FALSE) {
		crm_warn("MY NODE IS NOT IN CCM THE MEMBERSHIP LIST");
	}
	
	for(lpc=0; lpc<oc->m_n_in; lpc++) {
		crm_info("\tNEW:     %s [nodeid=%d, born=%d]",
		       oc->m_array[oc->m_in_idx+lpc].node_uname,
		       oc->m_array[oc->m_in_idx+lpc].node_id,
		       oc->m_array[oc->m_in_idx+lpc].node_born_on);
	}
	
	for(lpc=0; lpc<oc->m_n_out; lpc++) {
		crm_info("\tLOST:    %s [nodeid=%d, born=%d]",
		       oc->m_array[oc->m_out_idx+lpc].node_uname,
		       oc->m_array[oc->m_out_idx+lpc].node_id,
		       oc->m_array[oc->m_out_idx+lpc].node_born_on);
		if(fsa_our_uname != NULL
		   && 0 == strcmp(fsa_our_uname,
			     oc->m_array[oc->m_out_idx+lpc].node_uname)) {
			crm_err("We're not part of the cluster anymore");
		}
	}
	
	crm_info("-----------------------");
	
}

int
register_with_ccm(ll_cluster_t *hb_cluster)
{
	return 0;
}

void 
msg_ccm_join(const HA_Message *msg, void *foo)
{
	
	crm_verbose("\n###### Recieved ccm_join message...");
	if (msg != NULL)
	{
		crm_verbose("[type=%s]",
			    ha_msg_value(msg, F_TYPE));
		crm_verbose("[orig=%s]",
			    ha_msg_value(msg, F_ORIG));
		crm_verbose("[to=%s]",
			    ha_msg_value(msg, F_TO));
		crm_verbose("[status=%s]",
			    ha_msg_value(msg, F_STATUS));
		crm_verbose("[info=%s]",
			    ha_msg_value(msg, F_COMMENT));
		crm_verbose("[rsc_hold=%s]",
			    ha_msg_value(msg, F_RESOURCES));
		crm_verbose("[stable=%s]",
			    ha_msg_value(msg, F_ISSTABLE));
		crm_verbose("[rtype=%s]",
			    ha_msg_value(msg, F_RTYPE));
		crm_verbose("[ts=%s]",
			    ha_msg_value(msg, F_TIME));
		crm_verbose("[seq=%s]",
			    ha_msg_value(msg, F_SEQ));
		crm_verbose("[generation=%s]",
			    ha_msg_value(msg, F_HBGENERATION));
		/*      crm_verbose("[=%s]", ha_msg_value(msg, F_)); */
	}
	return;
}

struct update_data_s
{
		crm_data_t *updates;
		const char *state;
		const char *join;
};

crm_data_t*
do_update_cib_nodes(crm_data_t *updates, gboolean overwrite)
{
	struct update_data_s update_data;
	crm_data_t *fragment = updates;
	crm_data_t *tmp = NULL;
	
	if(updates == NULL) {
		fragment = create_cib_fragment(NULL, NULL);
	}

	tmp = find_xml_node(fragment, XML_TAG_CIB, TRUE);
	tmp = get_object_root(XML_CIB_TAG_STATUS, tmp);
	CRM_DEV_ASSERT(tmp != NULL);
	
	update_data.updates = tmp;

	update_data.state = XML_BOOLEAN_NO;
	update_data.join  = CRMD_JOINSTATE_DOWN;
	if(fsa_membership_copy->dead_members != NULL) {
		g_hash_table_foreach(fsa_membership_copy->dead_members,
				     ghash_update_cib_node, &update_data);
	}
	
	update_data.state = XML_BOOLEAN_YES;
	update_data.join  = NULL;
	if(overwrite) {
		update_data.join = CRMD_JOINSTATE_PENDING;
	}
	
	if(fsa_membership_copy->members != NULL) {
		g_hash_table_foreach(fsa_membership_copy->members,
				     ghash_update_cib_node, &update_data);
	}

	/* this is most likely overkill...
	 *
	 * make *sure* that the join status of nodes entering the ccm list
	 *  is reset
	 *
	update_data.join = CRMD_JOINSTATE_PENDING;
	if(fsa_membership_copy->new_members != NULL) {
		g_hash_table_foreach(fsa_membership_copy->new_members,
				     ghash_update_cib_node, &update_data);
	}
*/
	if(update_data.updates != NULL) {
		update_local_cib(fragment);
	}

	/* so it can be freed */
	return fragment;

}

void
ghash_update_cib_node(gpointer key, gpointer value, gpointer user_data)
{
	crm_data_t *tmp1 = NULL;
	const char *node_uname = (const char*)key;
	struct update_data_s* data = (struct update_data_s*)user_data;
	const char *state = data->join;

	crm_verbose("%s processing %s (%s)",
		  __FUNCTION__, node_uname, data->state);

	tmp1 = create_node_state(node_uname, node_uname,
				 NULL, data->state, NULL, state, NULL);

	add_node_copy(data->updates, tmp1);
	free_xml(tmp1);
}

gboolean
ghash_node_clfree(gpointer key, gpointer value, gpointer user_data)
{
	/* value->node_uname is free'd as "key" */
	if(key != NULL) {
		crm_free(key);
	}
	if(value != NULL) {
		crm_free(value);
	}
	return TRUE;
}