patch from Hans to support amf B types

git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@957 fd59a12c-fef9-0310-b244-a6a79926bd2f

exec/amf.c

@@ -122,8 +122,8 @@ struct healthcheck_active {
 	int active;
 };
 
-static char *presencestate_ntoa (OpenaisCfgPresenceStateT state);
-static char *operationalstate_ntoa (OpenaisCfgOperationalStateT state);
+static char *presencestate_ntoa (SaAmfPresenceStateT state);
+static char *operationalstate_ntoa (SaAmfOperationalStateT state);
 static char *hastate_ntoa (SaAmfHAStateT state);
 static char *readinessstate_ntoa (int state);
 
@@ -190,15 +190,15 @@ static void message_handler_req_exec_amf_administrative_state_group_set (
 
 void presence_state_comp_set (
 	struct amf_comp *comp,
-	OpenaisCfgPresenceStateT presence_state);
+	SaAmfPresenceStateT presence_state);
 
 void operational_state_comp_set (
 	struct amf_comp *comp,
-	OpenaisCfgOperationalStateT operational_state);
+	SaAmfOperationalStateT operational_state);
 
 void operational_state_unit_set (
 	struct amf_unit *unit,
-	OpenaisCfgOperationalStateT operational_state);
+	SaAmfOperationalStateT operational_state);
 
 int clc_instantiate_all (void);
 int clc_instantiate (struct amf_comp *comp);
@@ -639,31 +639,31 @@ printf ("waiting for pid %d to finish\n", pid);
 struct req_exec_amf_operational_state_comp_set {
 	struct req_header header;
 	SaNameT name;
-	OpenaisCfgOperationalStateT operational_state;
+	SaAmfOperationalStateT operational_state;
 };
 
 struct req_exec_amf_presence_state_comp_set {
 	struct req_header header;
 	SaNameT name;
-	OpenaisCfgPresenceStateT presence_state;
+	SaAmfPresenceStateT presence_state;
 };
 
 struct req_exec_amf_administrative_state_csi_set {
 	struct req_header header;
 	SaNameT name;
-	OpenaisCfgAdministrativeStateT presence_state;
+	SaAmfAdminStateT administrative_state;
 };
 
 struct req_exec_amf_administrative_state_unit_set {
 	struct req_header header;
 	SaNameT name;
-	OpenaisCfgAdministrativeStateT presence_state;
+	SaAmfAdminStateT administrative_state;
 };
 
 struct req_exec_amf_administrative_state_group_set {
 	struct req_header header;
 	SaNameT name;
-	OpenaisCfgAdministrativeStateT presence_state;
+	SaAmfAdminStateT administrative_state;
 };
 struct req_exec_amf_comp_restart {
 	struct req_header header;
@@ -717,7 +717,7 @@ int clc_terminate_callback (struct amf_comp *comp)
 	struct component_terminate_callback_data *component_terminate_callback_data;
 
 	printf ("clc_terminate_callback %p\n", comp->conn);
-	if (comp->presence_state != OPENAIS_CFG_PRESENCESTATE_INSTANTIATED) {
+	if (comp->presence_state != SA_AMF_PRESENCE_INSTANTIATED) {
 		printf ("component terminated but not instantiated %s - %d\n",
 			getSaNameT (&comp->name), comp->presence_state);
 		assert (0);
@@ -805,7 +805,7 @@ int clc_instantiate (struct amf_comp *comp)
 
 	printf ("clc instantiate for comp %s\n", getSaNameT (&comp->name));
 
-	presence_state_comp_set (comp, OPENAIS_CFG_PRESENCESTATE_INSTANTIATING);
+	presence_state_comp_set (comp, SA_AMF_PRESENCE_INSTANTIATING);
 	res = clc_interfaces[comp->comptype]->instantiate (comp);
 	return (res);
 }
@@ -816,8 +816,8 @@ int clc_terminate (struct amf_comp *comp)
 
 	printf ("clc terminate for comp %s\n", getSaNameT (&comp->name));
 assert (0);
-	operational_state_comp_set (comp, OPENAIS_CFG_OPERATIONALSTATE_DISABLED);
-	presence_state_comp_set (comp, OPENAIS_CFG_PRESENCESTATE_TERMINATING);
+	operational_state_comp_set (comp, SA_AMF_OPERATIONAL_DISABLED);
+	presence_state_comp_set (comp, SA_AMF_PRESENCE_TERMINATING);
 
 	res = clc_interfaces[comp->comptype]->terminate (comp);
 	return (0);
@@ -829,8 +829,8 @@ int clc_cleanup (struct amf_comp *comp)
 
 	printf ("clc cleanup for comp %s\n", getSaNameT (&comp->name));
 	comp_healthcheck_deactivate (comp);
-	operational_state_comp_set (comp, OPENAIS_CFG_OPERATIONALSTATE_DISABLED);
-	presence_state_comp_set (comp, OPENAIS_CFG_PRESENCESTATE_TERMINATING);
+	operational_state_comp_set (comp, SA_AMF_OPERATIONAL_DISABLED);
+	presence_state_comp_set (comp, SA_AMF_PRESENCE_TERMINATING);
 	res = clc_interfaces[comp->comptype]->cleanup (comp);
 	return (0);
 }
@@ -896,11 +896,11 @@ int amf_lib_exit_fn (void *conn)
 printf ("setting in exit fn to uninst for comp %p\n", comp);
 		presence_state_comp_set (
 			comp,
-			OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED);
+			SA_AMF_PRESENCE_UNINSTANTIATED);
 
 		operational_state_comp_set (
 			comp,
-			OPENAIS_CFG_OPERATIONALSTATE_DISABLED);
+			SA_AMF_OPERATIONAL_DISABLED);
 
 		comp_healthcheck_deactivate (comp);
 	}
@@ -1302,7 +1302,7 @@ void comp_healthcheck_deactivate (
 
 void presence_state_comp_set (
 	struct amf_comp *comp,
-	OpenaisCfgPresenceStateT presence_state)
+	SaAmfPresenceStateT presence_state)
 {
 	struct req_exec_amf_presence_state_comp_set req_exec_amf_presence_state_comp_set;
 	struct iovec iovec;
@@ -1335,17 +1335,17 @@ void readiness_state_comp_set (struct amf_comp *comp)
 	 * if unit in service and component is enabled, it is in service
 	 * otherwise it is out of service page 37
 	 */
-	if (comp->unit->readiness_state == OPENAIS_CFG_READINESSSTATE_INSERVICE &&
-		comp->operational_state == OPENAIS_CFG_OPERATIONALSTATE_ENABLED) {
-		comp->readiness_state = OPENAIS_CFG_READINESSSTATE_INSERVICE;
+	if (comp->unit->readiness_state == SA_AMF_READINESS_IN_SERVICE &&
+		comp->operational_state == SA_AMF_OPERATIONAL_ENABLED) {
+		comp->readiness_state = SA_AMF_READINESS_IN_SERVICE;
 	} else {
-		comp->readiness_state = OPENAIS_CFG_READINESSSTATE_OUTOFSERVICE;
+		comp->readiness_state = SA_AMF_READINESS_OUT_OF_SERVICE;
 	}
 	printf ("readiness_state_comp_set (%s)\n",
 		operationalstate_ntoa (comp->operational_state));
 }
 
-void operational_state_comp_set (struct amf_comp *comp, OpenaisCfgOperationalStateT operational_state)
+void operational_state_comp_set (struct amf_comp *comp, SaAmfOperationalStateT operational_state)
 {
 	struct req_exec_amf_operational_state_comp_set req_exec_amf_operational_state_comp_set;
 	struct iovec iovec;
@@ -1388,7 +1388,7 @@ void csi_comp_set_callback (
 	name_value_list != &csi->name_value_head;
 	name_value_list = name_value_list->next) {
 	num_of_csi_attrs++;
-	name_value = list_entry (name_value_list, struct amf_csi_name_value, list);
+	name_value = list_entry (name_value_list, struct amf_csi_name_value, csi_name_list);
 	printf("\t\tname = %s, value = %s\n", name_value->name, name_value->value);
 	char_legnth_of_csi_attrs += strlen(name_value->name);
 	char_legnth_of_csi_attrs += strlen(name_value->value);
@@ -1420,7 +1420,7 @@ void csi_comp_set_callback (
 	 name_value_list != &csi->name_value_head;
 	 name_value_list = name_value_list->next) {
        
-	  name_value = list_entry (name_value_list, struct amf_csi_name_value, list);
+	  name_value = list_entry (name_value_list, struct amf_csi_name_value, csi_name_list);
 	  
 	  strcpy(&csi_attribute_buf[byte_offset],
 		 (char*)name_value->name);
@@ -1505,7 +1505,7 @@ void csi_comp_set_callback (
 		csi_set_callback_data);
 
 	
-	int result = openais_conn_send_response (
+	openais_conn_send_response (
 	    openais_conn_partner_get (comp->conn),
 	    res_lib_amf_csisetcallback,
 	    res_lib_amf_csisetcallback->header.size);
@@ -1570,7 +1570,7 @@ void csi_unit_set_callback (struct amf_unit *unit, struct amf_si *si)
                       csilist != &si->csi_head;
                       csilist = csilist->next) {
 
-                        csi = list_entry (csilist, struct amf_csi, list);
+                        csi = list_entry (csilist, struct amf_csi, csi_list);
 
                         if (!memcmp(csi->type_name.value, type_name->name.value, type_name->name.length)) {
                                 csi_comp_set_callback (comp, csi, pg);
@@ -1710,7 +1710,7 @@ void unit_cleanup (struct amf_unit *unit)
 	
 void comp_restart (struct amf_comp *comp)
 {
-	presence_state_comp_set (comp, OPENAIS_CFG_PRESENCESTATE_RESTARTING);
+	presence_state_comp_set (comp, SA_AMF_PRESENCE_RESTARTING);
 }
 
 void unit_restart (struct amf_unit *unit)
@@ -1723,7 +1723,7 @@ void unit_restart (struct amf_unit *unit)
 		list_comp = list_comp->next) {
 
 		comp = list_entry (list_comp, struct amf_comp, comp_list);
-		presence_state_comp_set (comp, OPENAIS_CFG_PRESENCESTATE_RESTARTING);
+		presence_state_comp_set (comp, SA_AMF_PRESENCE_RESTARTING);
 	}
 }
 
@@ -1762,7 +1762,7 @@ void csi_unit_remove_callbacks (struct amf_unit *unit)
 			list_csi != &si->csi_head;
 			list_csi = list_csi->next) {
 
-			csi = list_entry (list_csi, struct amf_csi, list);
+			csi = list_entry (list_csi, struct amf_csi, csi_list);
 
 			for (list_comp = csi->unit->comp_head.next;
 				list_comp != &csi->unit->comp_head;
@@ -1827,9 +1827,8 @@ void csi_unit_create (struct amf_unit *unit, struct amf_si *si,
 	printf ("creating csi for si %p unit %p\n", si, unit);
 	si->csi_count += 1;
 	csi = malloc (sizeof (struct amf_csi));
-	list_init (&csi->list);
 	list_init (&csi->csi_list);
-	list_add (&csi->list, &si->csi_head);
+	list_add (&csi->csi_list, &si->csi_head);
 	list_add (&si->unit_list, &unit->si_head);
 	csi->si = si;
 	csi->unit = unit;
@@ -1869,7 +1868,7 @@ int unit_inservice_count (struct amf_group *group)
 		unit = list_entry (list,
 			struct amf_unit, unit_list);
 
-		if (unit->readiness_state == OPENAIS_CFG_READINESSSTATE_INSERVICE) {
+		if (unit->readiness_state == SA_AMF_READINESS_IN_SERVICE) {
 			answer += 1;
 		}
 	}
@@ -1887,7 +1886,7 @@ int comp_inservice_count (struct amf_unit *unit)
 		list = list->next) {
 
 		comp = list_entry (list, struct amf_comp, comp_list);
-		if (comp->readiness_state == OPENAIS_CFG_READINESSSTATE_INSERVICE) {
+		if (comp->readiness_state == SA_AMF_READINESS_IN_SERVICE) {
 			answer += 1;
 		}
 	}
@@ -1905,8 +1904,7 @@ int si_count (struct amf_group *group)
 		list_si != &group->si_head;
 		list_si = list_si->next) {
 
-		si = list_entry (list_si,
-			struct amf_si, list);
+		si = list_entry (list_si, struct amf_si, si_list);
 
 		answer += 1;
 	}
@@ -1947,7 +1945,7 @@ void assign_nm_active (struct amf_group *group, int su_units_assign)
 		unit = list_entry (list_unit,
 			struct amf_unit, unit_list);
 
-		if (unit->readiness_state != OPENAIS_CFG_READINESSSTATE_INSERVICE) {
+		if (unit->readiness_state != SA_AMF_READINESS_IN_SERVICE) {
 			list_unit = list_unit->next;
 			continue; /* Not in service */
 		}
@@ -1957,7 +1955,7 @@ void assign_nm_active (struct amf_group *group, int su_units_assign)
 			assigned < assign_per_su &&
 			total_assigned < si_count (group)) {
 
-			si = list_entry (list_si, struct amf_si, list);
+			si = list_entry (list_si, struct amf_si, si_list);
 			assigned += 1;
 			total_assigned += 1;
 			ha_state_unit_set (unit, si, SA_AMF_HA_ACTIVE);
@@ -1991,7 +1989,7 @@ void assign_nm_standby (struct amf_group *group, int units_assign_standby)
 		unit = list_entry (list_unit,
 			struct amf_unit, unit_list);
 
-		if (unit->readiness_state != OPENAIS_CFG_READINESSSTATE_INSERVICE ||
+		if (unit->readiness_state != SA_AMF_READINESS_IN_SERVICE ||
 			unit->requested_ha_state == SA_AMF_HA_ACTIVE) {
 
 			list_unit = list_unit->next;
@@ -2000,7 +1998,7 @@ void assign_nm_standby (struct amf_group *group, int units_assign_standby)
 
 		assigned = 0;
 		while (list_si != &group->si_head && assigned < assign_per_su) {
-			si = list_entry (list_si, struct amf_si, list);
+			si = list_entry (list_si, struct amf_si, si_list);
 			assigned += 1;
 			ha_state_unit_set (unit, si, SA_AMF_HA_STANDBY);
 			list_si = list_si->next;
@@ -2021,7 +2019,7 @@ void assign_nm_spare (struct amf_group *group)
 		unit = list_entry (list,
 			struct amf_unit, unit_list);
 
-		if (unit->readiness_state == OPENAIS_CFG_READINESSSTATE_INSERVICE &&
+		if (unit->readiness_state == SA_AMF_READINESS_IN_SERVICE &&
 			(unit->requested_ha_state != SA_AMF_HA_ACTIVE &&
 			unit->requested_ha_state != SA_AMF_HA_STANDBY)) {
 
@@ -2145,7 +2143,7 @@ void assign_sis (struct amf_group *group)
 	assign_nm_standby (group, su_standby_assign);
 }
 
-void readiness_state_unit_set (struct amf_unit *unit, OpenaisCfgReadinessStateT readiness_state)
+void readiness_state_unit_set (struct amf_unit *unit, SaAmfReadinessStateT readiness_state)
 {
 	printf ("Assigning unit %s ",
 		getSaNameT (&unit->name));
@@ -2156,7 +2154,7 @@ void readiness_state_unit_set (struct amf_unit *unit, OpenaisCfgReadinessStateT
 	assign_sis (unit->amf_group);
 }
 
-void presence_state_unit_set (struct amf_unit *unit, OpenaisCfgPresenceStateT presence_state)
+void presence_state_unit_set (struct amf_unit *unit, SaAmfPresenceStateT presence_state)
 {
 	printf ("Setting service unit presence state %s\n",
 		presencestate_ntoa (presence_state));
@@ -2169,11 +2167,11 @@ static void escalation_policy_restart (struct amf_comp *comp)
 printf ("escalation policy restart uninsint %p\n", comp);
 	presence_state_comp_set (
 		comp,
-		OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED);
+		SA_AMF_PRESENCE_UNINSTANTIATED);
 
 	operational_state_comp_set (
 		comp,
-		OPENAIS_CFG_OPERATIONALSTATE_DISABLED);
+		SA_AMF_OPERATIONAL_DISABLED);
 
 	switch (comp->unit->escalation_level) {
 
@@ -2369,7 +2367,7 @@ void healthcheck_unit_activate (
 
 void operational_state_unit_set (
 	struct amf_unit *unit,
-	OpenaisCfgOperationalStateT operational_state)
+	SaAmfOperationalStateT operational_state)
 {
 	if (operational_state == unit->operational_state) {
 		printf ("Not assigning service unit new operational state - same state\n");
@@ -2378,17 +2376,17 @@ void operational_state_unit_set (
 	unit->operational_state = operational_state;
 	printf ("Service unit operational state set to %s\n",
 		operationalstate_ntoa (operational_state));
-	if (operational_state == OPENAIS_CFG_OPERATIONALSTATE_ENABLED) {
+	if (operational_state == SA_AMF_OPERATIONAL_ENABLED) {
 		readiness_state_unit_set (unit,
-			OPENAIS_CFG_READINESSSTATE_INSERVICE);
+			SA_AMF_READINESS_IN_SERVICE);
 		/*
 		 * Start healthcheck now
 		 */
 // TODO		healthcheck_unit_activate (unit);
 	} else
-	if (operational_state == OPENAIS_CFG_OPERATIONALSTATE_DISABLED) {
+	if (operational_state == SA_AMF_OPERATIONAL_DISABLED) {
 		readiness_state_unit_set (unit,
-			OPENAIS_CFG_READINESSSTATE_OUTOFSERVICE);
+			SA_AMF_READINESS_OUT_OF_SERVICE);
 //		ha_state_unit_set (unit, si, SA_AMF_HA_STANDBY);
 
 //		healthcheck_unit_deactivate (unit);
@@ -2422,17 +2420,17 @@ static void message_handler_req_exec_amf_operational_state_comp_set (
 
 		comp_compare = list_entry (list,
 			struct amf_comp, comp_list);
-		if (comp_compare->operational_state != OPENAIS_CFG_OPERATIONALSTATE_ENABLED) {
+		if (comp_compare->operational_state != SA_AMF_OPERATIONAL_ENABLED) {
 			all_set = 0;
 			break;
 		}
 	}
 	if (all_set) {
 		operational_state_unit_set (comp->unit, 
-			OPENAIS_CFG_OPERATIONALSTATE_ENABLED);
+			SA_AMF_OPERATIONAL_ENABLED);
 	} else {
 		operational_state_unit_set (comp->unit, 
-			OPENAIS_CFG_OPERATIONALSTATE_DISABLED);
+			SA_AMF_OPERATIONAL_DISABLED);
 	}
 	readiness_state_comp_set (comp);
 }
@@ -2454,22 +2452,22 @@ static void message_handler_req_exec_amf_presence_state_comp_set (
 		return;
 	}
 
-	if (req_exec_amf_presence_state_comp_set->presence_state == OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED) {
+	if (req_exec_amf_presence_state_comp_set->presence_state == SA_AMF_PRESENCE_UNINSTANTIATED) {
 		comp->conn = 0;
 	}
 
 	/*
 	 * The restarting state can only be entered from the uninstantiated state
 	 */
-	if (req_exec_amf_presence_state_comp_set->presence_state == OPENAIS_CFG_PRESENCESTATE_RESTARTING &&
-		comp->presence_state != OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED) {
+	if (req_exec_amf_presence_state_comp_set->presence_state == SA_AMF_PRESENCE_RESTARTING &&
+		comp->presence_state != SA_AMF_PRESENCE_UNINSTANTIATED) {
 
 printf ("restart presence state set even though not in terminating state\n");
 		return;
 	}
 
 	comp->presence_state = req_exec_amf_presence_state_comp_set->presence_state;
-	if (comp->presence_state == OPENAIS_CFG_PRESENCESTATE_RESTARTING) {
+	if (comp->presence_state == SA_AMF_PRESENCE_RESTARTING) {
 		printf ("SET TO RESTARTING instantiating now\n");
 		clc_instantiate (comp);
 	}
@@ -2491,7 +2489,7 @@ printf ("restart presence state set even though not in terminating state\n");
 
 		comp_compare = list_entry (list,
 			struct amf_comp, comp_list);
-		if (comp_compare->presence_state != OPENAIS_CFG_PRESENCESTATE_INSTANTIATED) {
+		if (comp_compare->presence_state != SA_AMF_PRESENCE_INSTANTIATED) {
 			all_set = 0;
 			break;
 		}
@@ -2499,7 +2497,7 @@ printf ("restart presence state set even though not in terminating state\n");
 
 	if (all_set) {
 		presence_state_unit_set (comp->unit, 
-			OPENAIS_CFG_PRESENCESTATE_INSTANTIATED);
+			SA_AMF_PRESENCE_INSTANTIATED);
 	}
 }
 
@@ -2546,9 +2544,9 @@ static void message_handler_req_lib_amf_componentregister (
 	comp = find_comp (&req_lib_amf_componentregister->compName);
 	if (comp) {
 		presence_state_comp_set (comp,
-			OPENAIS_CFG_PRESENCESTATE_INSTANTIATED);
+			SA_AMF_PRESENCE_INSTANTIATED);
 		operational_state_comp_set (comp,
-			OPENAIS_CFG_OPERATIONALSTATE_ENABLED);
+			SA_AMF_OPERATIONAL_ENABLED);
 		comp->conn = conn;
 		amf_pd->comp = comp;
 		comp_healthcheck_activate (comp);
@@ -2673,7 +2671,7 @@ printf ("Activating healthcheck for the first time %p\n", healthcheck_active);
 
 #ifdef TODO
 do we want to do healtchecking only when full su has registered or also of non-fully registered sus
-	if (comp->unit->operational_state == OPENAIS_CFG_OPERATIONALSTATE_ENABLED) {
+	if (comp->unit->operational_state == SA_AMF_OPERATIONAL_ENABLED) {
 		/*
 		 * Start healthcheck now
 		 */
@@ -3021,7 +3019,7 @@ static void message_handler_req_lib_amf_response (void *conn, void *msg)
 		printf ("response from removing the CSI\n");
 // AAAA
 		list_del (&csi_remove_callback_data->csi->si->unit_list);
-		list_del (&csi_remove_callback_data->csi->list);
+		list_del (&csi_remove_callback_data->csi->csi_list);
 		free (csi_remove_callback_data);
 		break;
 
@@ -4817,7 +4815,7 @@ static char presence_state_text[8][32] = {
 	"terminiation_failed"
 };
 
-static char *presencestate_ntoa (OpenaisCfgPresenceStateT state)
+static char *presencestate_ntoa (SaAmfPresenceStateT state)
 {
 	static char str[32];
 
@@ -4834,7 +4832,7 @@ static char operational_state_text[4][64] = {
 	"disabled"
 };
 
-static char *operationalstate_ntoa (OpenaisCfgOperationalStateT state)
+static char *operationalstate_ntoa (SaAmfOperationalStateT state)
 {
 	static char str[32];
 

exec/amfconfig.c

@@ -294,10 +294,10 @@ extern int openais_amf_config_read (char **error_string)
 			} else
 			if ((loc = strstr_rs (line, "model=")) != 0) {
 				if (strcmp (loc, "2n") == 0) {
-					amf_group->model = GROUPCAPABILITYMODEL_2N;
+					amf_group->model = SA_AMF_2N_REDUNDANCY_MODEL;
 				} else
 				if (strcmp (loc, "nplusm") == 0) {
-					amf_group->model = GROUPCAPABILITYMODEL_NPLUSM;
+					amf_group->model = SA_AMF_NPM_REDUNDANCY_MODEL;
 				} else
 				if (strcmp (loc, "nway") == 0) {
 					printf ("nway redundancy model not supported.\n");
@@ -308,7 +308,7 @@ extern int openais_amf_config_read (char **error_string)
 					goto parse_error;
 				} else
 				if (strcmp (loc, "noredundancy") == 0) {
-					amf_group->model = GROUPCAPABILITYMODEL_NOREDUNDANCY;
+					amf_group->model = SA_AMF_NO_REDUNDANCY_MODEL;
 				} else {
 					goto parse_error;
 				}
@@ -353,8 +353,8 @@ extern int openais_amf_config_read (char **error_string)
 				memset (amf_unit, 0, sizeof (struct amf_unit));
 				amf_unit->amf_group = amf_group;
 
-				amf_unit->operational_state = OPENAIS_CFG_OPERATIONALSTATE_DISABLED;
-				amf_unit->presence_state = OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED;
+				amf_unit->operational_state = SA_AMF_OPERATIONAL_DISABLED;
+				amf_unit->presence_state = SA_AMF_PRESENCE_UNINSTANTIATED;
 				list_init (&amf_unit->comp_head);
 				list_init (&amf_unit->si_head);
 				amf_unit->escalation_level = ESCALATION_LEVEL_NO_ESCALATION;
@@ -370,7 +370,7 @@ extern int openais_amf_config_read (char **error_string)
 				list_init (&amf_si->csi_head);
 				list_init (&amf_si->unit_list);
 				list_init (&amf_si->pg_head);
-				list_add_tail (&amf_si->list, &amf_group->si_head);
+				list_add_tail (&amf_si->si_list, &amf_group->si_head);
 				amf_si->group = amf_group;
 				current_parse = AMF_SERVICEINSTANCE;
 			} else
@@ -389,8 +389,8 @@ extern int openais_amf_config_read (char **error_string)
 				amf_comp = (struct amf_comp *)mempool_malloc (sizeof (struct amf_comp));
 				memset (amf_comp, 0, sizeof (struct amf_comp));
 				amf_comp->unit = amf_unit;
-				amf_comp->operational_state = OPENAIS_CFG_OPERATIONALSTATE_DISABLED;
-				amf_comp->presence_state = OPENAIS_CFG_PRESENCESTATE_UNINSTANTIATED;
+				amf_comp->operational_state = SA_AMF_OPERATIONAL_DISABLED;
+				amf_comp->presence_state = SA_AMF_PRESENCE_UNINSTANTIATED;
 
 				list_init (&amf_comp->comp_list);
 				list_init (&amf_comp->healthcheck_list);
@@ -529,9 +529,9 @@ extern int openais_amf_config_read (char **error_string)
                         if ((loc = strstr_rs (line, "csi_descriptor{")) != 0) {
                                 amf_csi = (struct amf_csi*)mempool_malloc (sizeof(struct amf_csi));
 
-                                list_init(&amf_csi->list);
+                                list_init(&amf_csi->csi_list);
                                 list_init(&amf_csi->name_value_head);
-                                list_add_tail (&amf_csi->list, &amf_si->csi_head);
+                                list_add_tail (&amf_csi->csi_list, &amf_si->csi_head);
 
                                 current_parse = AMF_SERVICEINSTANCE_CSIDESCRIPTOR;
                         } else
@@ -551,8 +551,8 @@ extern int openais_amf_config_read (char **error_string)
                         if ((loc = strstr_rs (line, "name_value{")) != 0) {
                                  csi_name_value = (struct amf_csi_name_value*)mempool_malloc (sizeof(struct amf_csi_name_value));
 
-                                 list_init(&csi_name_value->list);
-                                 list_add_tail (&csi_name_value->list, &amf_csi->name_value_head);
+                                 list_init(&csi_name_value->csi_name_list);
+                                 list_add_tail (&csi_name_value->csi_name_list, &amf_csi->name_value_head);
 
                                  current_parse = AMF_SERVICEINSTANCE_CSIDESCRIPTOR_NAMEVALUE;
                         } else

exec/amfconfig.h

@@ -36,28 +36,10 @@
 #include "../include/saAmf.h"
 #include "../include/list.h"
 #include "aispoll.h"
-#include "../include/openaisCfg.h"
 
 #ifndef AMFCONFIG_H_DEFINED
 #define AMFCONFIG_H_DEFINED
 
-typedef enum {
-	GROUPCAPABILITYMODEL_2N,
-	GROUPCAPABILITYMODEL_NPLUSM,
-	GROUPCAPABILITYMODEL_NWAY,
-	GROUPCAPABILITYMODEL_NWAYACTIVE,
-	GROUPCAPABILITYMODEL_NOREDUNDANCY
-} SaAmfGroupCapabilityModelT;
-
-#ifdef COMPILE_OUT
-enum amfOperationalAdministrativeState {
-	AMF_DISABLED_UNLOCKED = 0,
-	AMF_DISABLED_LOCKED = 1,
-	AMF_ENABLED_UNLOCKED = 2,
-	AMF_ENABLED_STOPPING = 3
-};
-#endif
-
 struct amf_healthcheck {
 	SaAmfHealthcheckKeyT key;
 	SaTimeT period;
@@ -68,9 +50,9 @@ struct amf_healthcheck {
 
 enum escalation_levels {
 	ESCALATION_LEVEL_NO_ESCALATION = 1,	/* execute component restart */
-        ESCALATION_LEVEL_ONE = 2,		/* escalate to service unit restart */
-        ESCALATION_LEVEL_TWO = 3,		/* escalate to service unit failover */
-        ESCALATION_LEVEL_THREE = 4		/* escalate to node failover */
+	ESCALATION_LEVEL_ONE = 2,		/* escalate to service unit restart */
+	ESCALATION_LEVEL_TWO = 3,		/* escalate to service unit failover */
+	ESCALATION_LEVEL_THREE = 4		/* escalate to node failover */
 };
 
 struct amf_unit {
@@ -79,11 +61,10 @@ struct amf_unit {
 	struct list_head unit_list;
 	struct amf_group *amf_group;
 	struct list_head si_head;
-	struct list_head si_list;
 	int si_count;
-	OpenaisCfgPresenceStateT presence_state;
-	OpenaisCfgOperationalStateT operational_state;
-	OpenaisCfgReadinessStateT readiness_state;
+	SaAmfPresenceStateT presence_state;
+	SaAmfOperationalStateT operational_state;
+	SaAmfReadinessStateT readiness_state;
 	SaAmfHAStateT assigned_ha_state;
 	SaAmfHAStateT requested_ha_state;
 
@@ -96,16 +77,15 @@ struct amf_unit {
 };
 
 struct amf_csi_name_value {
-        struct list_head list;
-        char name[128];
-        char value[128];
+	struct list_head csi_name_list;
+	char name[128];
+	char value[128];
 };
 
 struct amf_si;
 struct amf_csi {
 	SaNameT name;
 	SaNameT type_name;
-	struct list_head list;
 	struct amf_unit *unit;
 	struct list_head csi_list;
 	struct list_head unit_head;
@@ -117,13 +97,13 @@ struct amf_csi {
 struct amf_si {
 	SaNameT name;
 	int csi_count;
-	struct list_head list;
+	struct list_head si_list;
 	struct amf_group *group;
 	struct list_head csi_head;
 	struct list_head pg_head;
 	struct list_head unit_list;
-	OpenaisCfgAdministrativeStateT administrative_state;
-	OpenaisCfgOperationalStateT operational_state;
+	SaAmfAdminStateT administrative_state;
+	SaAmfOperationalStateT operational_state;
 };
 
 struct amf_pg {
@@ -141,12 +121,12 @@ struct amf_pg_comp {
 
 struct amf_group {
 	SaNameT name;
-	SaAmfGroupCapabilityModelT model;
+	saAmfRedundancyModelT model;
 	SaUint32T preferred_active_units;
 	SaUint32T preferred_standby_units;
 	SaUint32T maximum_active_instances;
 	SaUint32T maximum_standby_instances;
-	OpenaisCfgAdministrativeStateT administrativeState;
+	SaAmfAdminStateT administrative_state;
 	struct list_head group_list;
 	struct list_head unit_head;
 	struct list_head si_head;
@@ -195,16 +175,15 @@ struct amf_comp {
 	char am_start_cmd[1024];
 	char am_stop_cmd[1024];
 	
-	OpenaisCfgAdministrativeStateT administrative_state;
-	OpenaisCfgOperationalStateT operational_state;
-	OpenaisCfgReadinessStateT readiness_state;
+	SaAmfOperationalStateT operational_state;
+	SaAmfReadinessStateT readiness_state;
 	SaAmfHAStateT ha_state;
-	OpenaisCfgPresenceStateT presence_state;
+	SaAmfPresenceStateT presence_state;
 };
 
 struct amf_comp_csi_type_name {
 	struct list_head list;
-        SaNameT name;
+	SaNameT name;
 };
 
 extern struct list_head amf_group_head;

exec/main.c

@@ -1020,7 +1020,6 @@ static void aisexec_mempool_init (void)
 
 static void aisexec_tty_detach (void)
 {
-#define DEBUG
 #ifndef DEBUG
 	/*
 	 * Disconnect from TTY if this is not a debug run

include/saAis.h

@@ -52,6 +52,9 @@ typedef uint16_t SaUint16T;
 typedef uint32_t SaUint32T;
 typedef uint64_t SaUint64T;
 
+typedef float SaFloatT;
+typedef double SaDoubleT;
+typedef char * SaStringT;
 typedef SaInt64T SaTimeT;
 
 #define SA_TIME_END ((SaTimeT)0x7fffffffffffffffull)

include/saAmf.h

@@ -69,6 +69,55 @@ typedef enum {
 	SA_AMF_HA_QUIESCING = 4
 } SaAmfHAStateT;
 
+typedef enum {
+	SA_AMF_READINESS_OUT_OF_SERVICE = 1,
+	SA_AMF_READINESS_IN_SERVICE = 2,
+	SA_AMF_READINESS_STOPPING = 3
+} SaAmfReadinessStateT;
+
+typedef enum {
+	SA_AMF_PRESENCE_UNINSTANTIATED = 1,
+	SA_AMF_PRESENCE_INSTANTIATING = 2,
+	SA_AMF_PRESENCE_INSTANTIATED = 3,
+	SA_AMF_PRESENCE_TERMINATING = 4,
+	SA_AMF_PRESENCE_RESTARTING = 5,
+	SA_AMF_PRESENCE_INSTANTIATION_FAILED = 6,
+	SA_AMF_PRESENCE_TERMINATION_FAILED = 7
+} SaAmfPresenceStateT;
+
+typedef enum {
+	SA_AMF_OPERATIONAL_ENABLED = 1,
+	SA_AMF_OPERATIONAL_DISABLED = 2
+} SaAmfOperationalStateT;
+
+typedef enum {
+	SA_AMF_ADMIN_UNLOCKED = 1,
+	SA_AMF_ADMIN_LOCKED = 2,
+	SA_AMF_ADMIN_LOCKED_INSTANTIATION = 3,
+	SA_AMF_ADMIN_SHUTTING_DOWN = 4
+} SaAmfAdminStateT;
+
+typedef enum {
+	SA_AMF_ASSIGNMENT_UNASSIGNED = 1,
+	SA_AMF_ASSIGNMENT_FULLY_ASSIGNED = 2,
+	SA_AMF_ASSIGNMENT_PARTIALLY_ASSIGNED = 3
+} SaAmfAssignmentStateT;
+
+typedef enum {
+	SA_AMF_PROXY_STATUS_UNPROXIED = 1,
+	SA_AMF_PROXY_STATUS_PROXIED = 2
+} SaAmfProxyStatusT;
+
+typedef enum {
+	SA_AMF_READINESS_STATE = 1,
+	SA_AMF_HA_STATE = 2,
+	SA_AMF_PRESENCE_STATE = 3,
+	SA_AMF_OP_STATE = 4,
+	SA_AMF_ADMIN_STATE = 5,
+	SA_AMF_ASSIGNMENT_STATE = 6,
+	SA_AMF_PROXY_STATUS = 7
+} SaAmfStateT;
+
 #define SA_AMF_CSI_ADD_ONE 0x1
 #define SA_AMF_CSI_TARGET_ONE 0x2
 #define SA_AMF_CSI_TARGET_ALL 0x4
@@ -148,9 +197,39 @@ typedef enum {
 	SA_AMF_NODE_SWITCHOVER = 4,
 	SA_AMF_NODE_FAILOVER = 5,
 	SA_AMF_NODE_FAILFAST = 6,
-	SA_AMF_CLUSTER_RESET = 7
+	SA_AMF_CLUSTER_RESET = 7,
+	SA_AMF_APPLICATION_RESTART = 8
 } SaAmfRecommendedRecoveryT;
 
+#define SA_AMF_COMP_SA_AWARE 0x0001
+#define SA_AMF_COMP_PROXY 0x0002
+#define SA_AMF_COMP_PROXIED 0x0004
+#define SA_AMF_COMP_LOCAL 0x0008
+typedef SaUint32T saAmfCompCategoryT;
+
+typedef enum {								
+	SA_AMF_2N_REDUNDANCY_MODEL = 1,
+	SA_AMF_NPM_REDUNDANCY_MODEL = 2,
+	SA_AMF_N_WAY_REDUNDANCY_MODEL = 3,
+	SA_AMF_N_WAY_ACTIVE_REDUNDACY_MODEL = 4,
+	SA_AMF_NO_REDUNDANCY_MODEL= 5
+} saAmfRedundancyModelT;
+
+typedef enum {								
+	SA_AMF_COMP_X_ACTIVE_AND_Y_STANDBY = 1,
+	SA_AMF_COMP_X_ACTIVE_OR_Y_STANDBY = 2,
+	SA_AMF_COMP_ONE_ACTIVE_OR_Y_STANDBY = 3,
+	SA_AMF_COMP_ONE_ACTIVE_OR_ONE_STANDBY = 4,
+	SA_AMF_COMP_X_ACTIVE = 5,
+	SA_AMF_COMP_1_ACTIVE = 6,
+	SA_AMF_COMP_NON_PRE_INSTANTIABLE = 7
+} saAmfCompCapabilityModelT;
+
+typedef enum {
+	SA_AMF_NODE_NAME = 1,
+	SA_AMF_SI_NAME = 2
+} SaAmfAdditionalInfoIdT;
+
 typedef void (*SaAmfHealthcheckCallbackT) (
 	SaInvocationT invocation,
 	const SaNameT *compName,
@@ -198,9 +277,9 @@ typedef struct {
 	SaAmfProtectionGroupTrackCallbackT
 		saAmfProtectionGroupTrackCallback;
 	SaAmfExternalComponentInstantiateCallbackT
-		saAmfExternalComponentInstantiateCallback;
+		saAmfProxiedComponentInstantiateCallback;
 	SaAmfExternalComponentCleanupCallbackT
-		saAmfExternalComponentCleanupCallback;
+		saAmfProxiedComponentCleanupCallback;
 } SaAmfCallbacksT;
 
 /*
@@ -300,7 +379,7 @@ saAmfCSIQuiescingComplete(
 	SaAisErrorT error);
 
 SaAisErrorT
-saAmfProtectionGroupTrackStart (
+saAmfProtectionGroupTrack (
 	SaAmfHandleT amfHandle,
 	const SaNameT *csiName,
 	SaUint8T trackFlags,

lib/amf.c

@@ -866,7 +866,7 @@ saAmfCSIQuiescingComplete (
 }
 
 SaAisErrorT
-saAmfProtectionGroupTrackStart (
+saAmfProtectionGroupTrack (
 	SaAmfHandleT amfHandle,
 	const SaNameT *csiName,
 	SaUint8T trackFlags,

test/testamf.c

@@ -319,7 +319,7 @@ int main (int argc, char **argv) {
 	result = saAmfComponentCapabilityModelGet (&compName, &componentCapabilityModel);
 	printf ("component capability model get is %d (should be 1)\n", result);
 
-	result = saAmfProtectionGroupTrackStart (&handle, &csiName, SA_TRACK_CURRENT | SA_TRACK_CHANGES, protectionGroupNotificationBuffer, 64);
+	result = saAmfProtectionGroupTrack (&handle, &csiName, SA_TRACK_CURRENT | SA_TRACK_CHANGES, protectionGroupNotificationBuffer, 64);
 	printf ("track start result is %d (should be 1)\n", result);
 
 	result = saAmfProtectionGroupTrackStop (&handle, &csiName);