proxmox-mirrors/mirror_corosync
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_corosync synced 2025-06-14 07:40:03 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6fdfd15c17
mirror_corosync/exec/amfconfig.c
Steven Dake 7b2ddfa428 enhancement 1020 
Adds AMF B.01.01 support - still needs alot of work


git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@879 fd59a12c-fef9-0310-b244-a6a79926bd2f
2006-01-03 05:51:38 +00:00

533 lines
16 KiB
C
Raw Blame History

/*
* Copyright (c) 2002-2005 MontaVista Software, Inc.
*
* All rights reserved.
*
* Author: Steven Dake (sdake@mvista.com)
*
* This software licensed under BSD license, the text of which follows:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the MontaVista Software, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "../include/saAis.h"
#include "../include/saAmf.h"
#include "../include/ipc_amf.h"
#include "../include/list.h"
#include "util.h"
#include "amfconfig.h"
#include "mainconfig.h"
#include "mempool.h"
#include "print.h"
#include "totem.h"
DECLARE_LIST_INIT (amf_groupHead);
DECLARE_LIST_INIT (amf_healthcheck_head);
static char error_string_response[512];
typedef enum {
AMF_HEAD,
AMF_GROUP,
AMF_UNIT,
AMF_COMPONENT,
AMF_SERVICEINSTANCE,
AMF_HEALTHCHECK
} amf_parse_t;
typedef enum {
MAIN_HEAD,
MAIN_NETWORK,
MAIN_LOGGING,
MAIN_KEY,
MAIN_TIMEOUT,
MAIN_EVENT
} main_parse_t;
void setSaNameT (SaNameT *name, char *str) {
strncpy ((char *)name->value, str, SA_MAX_NAME_LENGTH);
if (strlen ((char *)name->value) > SA_MAX_NAME_LENGTH) {
name->length = SA_MAX_NAME_LENGTH;
} else {
name->length = strlen (str);
}
}
int SaNameTisEqual (SaNameT *str1, char *str2) {
if (str1->length == strlen (str2)) {
return ((strncmp ((char *)str1->value, (char *)str2,
str1->length)) == 0);
} else {
return 0;
}
}
struct amf_healthcheck *find_healthcheck (SaAmfHealthcheckKeyT *key)
{
struct amf_healthcheck *healthcheck;
struct amf_healthcheck *ret_healthcheck = 0;
struct list_head *list;
for (list = amf_healthcheck_head.next;
list != &amf_healthcheck_head;
list = list->next) {
healthcheck = list_entry (list,
struct amf_healthcheck, list);
if (memcmp (key, &healthcheck->key, sizeof (SaAmfHealthcheckKeyT)) == 0) {
ret_healthcheck = healthcheck;
break;
}
}
return (ret_healthcheck);
}
struct amf_comp *find_comp (SaNameT *name)
{
struct list_head *list_group = 0;
struct list_head *list_unit = 0;
struct list_head *AmfComponentList = 0;
struct amf_group *amf_group = 0;
struct amf_unit *amf_unit = 0;
struct amf_comp *AmfComponent = 0;
int found = 0;
/*
* Search all groups
*/
for (list_group = amf_groupHead.next;
list_group != &amf_groupHead && found == 0;
list_group = list_group->next) {
amf_group = list_entry (list_group,
struct amf_group, group_list);
/*
* Search all units
*/
for (list_unit = amf_group->unit_head.next;
list_unit != &amf_group->unit_head && found == 0;
list_unit = list_unit->next) {
amf_unit = list_entry (list_unit,
struct amf_unit, unit_list);
/*
* Search all components
*/
for (AmfComponentList = amf_unit->comp_head.next;
AmfComponentList != &amf_unit->comp_head && found == 0;
AmfComponentList = AmfComponentList->next) {
AmfComponent = list_entry (AmfComponentList,
struct amf_comp, comp_list);
if (name_match (name, &AmfComponent->name)) {
found = 1;
}
}
}
}
if (found) {
return (AmfComponent);
} else {
return (0);
}
}
struct amf_unit *find_unit (SaNameT *name)
{
struct list_head *list_group = 0;
struct list_head *list_unit = 0;
struct amf_group *amf_group = 0;
struct amf_unit *amf_unit = 0;
int found = 0;
/*
* Search all groups
*/
for (list_group = amf_groupHead.next;
list_group != &amf_groupHead && found == 0;
list_group = list_group->next) {
amf_group = list_entry (list_group,
struct amf_group, group_list);
/*
* Search all units
*/
for (list_unit = amf_group->unit_head.next;
list_unit != &amf_group->unit_head && found == 0;
list_unit = list_unit->next) {
amf_unit = list_entry (list_unit,
struct amf_unit, unit_list);
if (name_match (name, &amf_unit->name)) {
found = 1;
}
}
}
if (found) {
return (amf_unit);
} else {
return (0);
}
}
extern int openais_amf_config_read (char **error_string)
{
char line[255];
FILE *fp;
amf_parse_t current_parse = AMF_HEAD;
int line_number = 0;
char *loc;
int i;
struct amf_group *amf_group = 0;
struct amf_unit *amf_unit = 0;
struct amf_comp *amf_comp = 0;
struct amf_si *amf_si = 0;
struct amf_healthcheck *amf_healthcheck = 0;
fp = fopen ("/etc/ais/groups.conf", "r");
if (fp == 0) {
sprintf (error_string_response,
"Can't read /etc/ais/groups.conf file reason = (%s).\n", strerror (errno));
*error_string = error_string_response;
return (-1);
}
while (fgets (line, 255, fp)) {
line_number += 1;
line[strlen(line) - 1] = '\0';
/*
* Clear out comments and empty lines
*/
if (line[0] == '#' || line[0] == '\0' || line[0] == '\n') {
continue;
}
/*
* Clear out white space and tabs
*/
for (i = strlen (line) - 1; i > -1; i--) {
if (line[i] == '\t' || line[i] == ' ') {
line[i] = '\0';
} else {
break;
}
}
switch (current_parse) {
case AMF_HEAD:
if (strstr_rs (line, "group{")) {
amf_group = (struct amf_group *)mempool_malloc (sizeof (struct amf_group));
memset (amf_group, 0, sizeof (struct amf_group));
list_init (&amf_group->group_list);
list_init (&amf_group->unit_head);
list_init (&amf_group->si_head);
list_add (&amf_group->group_list, &amf_groupHead);
memset (amf_group->clccli_path, 0, sizeof (&amf_unit->clccli_path));
memset (amf_group->binary_path, 0, sizeof (&amf_unit->binary_path));
current_parse = AMF_GROUP;
} else
if (strstr_rs (line, "healthcheck{")) {
amf_healthcheck = (struct amf_healthcheck *)mempool_malloc (sizeof (struct amf_healthcheck));
memset (amf_healthcheck, 0, sizeof (struct amf_healthcheck));
list_init (&amf_healthcheck->list);
list_add_tail (&amf_healthcheck->list,
&amf_healthcheck_head);
current_parse = AMF_HEALTHCHECK;
} else {
goto parse_error;
}
break;
case AMF_GROUP:
if ((loc = strstr_rs (line, "name=")) != 0) {
setSaNameT (&amf_group->name, loc);
} else
if ((loc = strstr_rs (line, "model=")) != 0) {
if (strcmp (loc, "2n") == 0) {
amf_group->model = GROUPCAPABILITYMODEL_2N;
} else
if (strcmp (loc, "nplusm") == 0) {
amf_group->model = GROUPCAPABILITYMODEL_NPLUSM;
} else
if (strcmp (loc, "nway") == 0) {
printf ("nway redundancy model not supported.\n");
goto parse_error;
} else
if (strcmp (loc, "nwayactive") == 0) {
printf ("nway active redundancy model not supported.\n");
goto parse_error;
} else
if (strcmp (loc, "noredundancy") == 0) {
amf_group->model = GROUPCAPABILITYMODEL_NOREDUNDANCY;
} else {
goto parse_error;
}
} else
if ((loc = strstr_rs (line, "preferred-active-units=")) != 0) {
amf_group->preferred_active_units = atoi (loc);
} else
if ((loc = strstr_rs (line, "preferred-standby-units=")) != 0) {
amf_group->preferred_standby_units = atoi (loc);
} else
if ((loc = strstr_rs (line, "maximum-active-instances=")) != 0) {
amf_group->maximum_active_instances = atoi (loc);
} else
if ((loc = strstr_rs (line, "maximum-standby-instances=")) != 0) {
amf_group->maximum_standby_instances = atoi (loc);
} else
if ((loc = strstr_rs (line, "clccli_path=")) != 0) {
strcpy (amf_group->clccli_path, loc);
} else
if ((loc = strstr_rs (line, "binary_path=")) != 0) {
strcpy (amf_group->binary_path, loc);
} else
if ((loc = strstr_rs (line, "component_restart_probation=")) != 0) {
amf_group->component_restart_probation = atoi (loc);
printf ("restart probation %d\n", amf_group->component_restart_probation);
} else
if ((loc = strstr_rs (line, "component_restart_max=")) != 0) {
amf_group->component_restart_max = atoi (loc);
printf ("restart max %d\n", amf_group->component_restart_max);
} else
if ((loc = strstr_rs (line, "unit_restart_probation=")) != 0) {
amf_group->unit_restart_probation = atoi (loc);
printf ("unit restart probation %d\n", amf_group->unit_restart_probation);
} else
if ((loc = strstr_rs (line, "unit_restart_max=")) != 0) {
amf_group->unit_restart_max = atoi (loc);
printf ("unit restart max %d\n", amf_group->unit_restart_max);
} else
if (strstr_rs (line, "unit{")) {
amf_unit = (struct amf_unit *)mempool_malloc (sizeof (struct amf_unit));
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;
list_init (&amf_unit->comp_head);
list_init (&amf_unit->si_head);
amf_unit->escalation_level = ESCALATION_LEVEL_NO_ESCALATION;
amf_unit->restart_count = 0;
list_add_tail (&amf_unit->unit_list, &amf_group->unit_head);
memset (amf_unit->clccli_path, 0, sizeof (&amf_unit->clccli_path));
memset (amf_unit->binary_path, 0, sizeof (&amf_unit->binary_path));
current_parse = AMF_UNIT;
} else
if (strstr_rs (line, "serviceinstance{")) {
amf_si = (struct amf_si *)mempool_malloc (sizeof (struct amf_si));
memset (amf_si, 0, sizeof (struct amf_si));
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);
amf_si->group = amf_group;
current_parse = AMF_SERVICEINSTANCE;
} else
if (strstr_rs (line, "}")) {
current_parse = AMF_HEAD;
} else {
goto parse_error;
}
break;
case AMF_UNIT:
if ((loc = strstr_rs (line, "name=")) != 0) {
setSaNameT (&amf_unit->name, loc);
} else
if ((loc = strstr_rs (line, "component{")) != 0) {
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;
list_init (&amf_comp->comp_list);
list_init (&amf_comp->healthcheck_list);
list_add_tail (&amf_comp->comp_list, &amf_unit->comp_head);
memset (amf_comp->clccli_path, 0, sizeof (&amf_comp->clccli_path));
memset (amf_comp->binary_path, 0, sizeof (&amf_unit->binary_path));
memset (amf_comp->binary_name, 0, sizeof (&amf_comp->binary_name));
current_parse = AMF_COMPONENT;
} else
if ((loc = strstr_rs (line, "clccli_path=")) != 0) {
strcpy (amf_unit->clccli_path, loc);
} else
if ((loc = strstr_rs (line, "binary_path=")) != 0) {
strcpy (amf_unit->binary_path, loc);
} else
if (strstr_rs (line, "}")) {
current_parse = AMF_GROUP;
} else {
goto parse_error;
}
break;
case AMF_COMPONENT:
if ((loc = strstr_rs (line, "name=")) != 0) {
setSaNameT (&amf_comp->name, loc);
} else
#ifdef COMPILE_OUT
if ((loc = strstr_rs (line, "model=")) != 0) {
if (strcmp (loc, "x_active_and_y_standby") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_X_ACTIVE_AND_Y_STANDBY;
} else
if (strcmp (loc, "x_active_or_y_standby") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_X_ACTIVE_OR_Y_STANDBY;
} else
if (strcmp (loc, "1_active_or_y_standby") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_1_ACTIVE_OR_Y_STANDBY;
} else
if (strcmp (loc, "1_active_or_1_standby") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_1_ACTIVE_OR_1_STANDBY;
} else
if (strcmp (loc, "x_active") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_X_ACTIVE;
} else
if (strcmp (loc, "1_active") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_1_ACTIVE;
} else
if (strcmp (loc, "no_active") == 0) {
amf_comp->componentCapabilityModel = SA_AMF_COMPONENT_CAPABILITY_NO_ACTIVE;
} else {
goto parse_error;
}
} else
#endif
if ((loc = strstr_rs(line, "comptype=")) != 0) {
if (strstr (line, "sa_aware")) {
amf_comp->comptype = clc_component_sa_aware;
} else
if (strstr (line, "proxied_pre")) {
amf_comp->comptype = clc_component_proxied_pre;
} else
if (strstr (line, "proxied_non_pre")) {
amf_comp->comptype = clc_component_proxied_non_pre;
} else
if (strstr (line, "non_proxied_non_sa_aware")) {
amf_comp->comptype = clc_component_proxied_non_pre;
} else {
goto parse_error;
}
} else
if ((loc = strstr_rs(line, "instantiate=")) != 0) {
strcpy (amf_comp->instantiate_cmd, loc);
} else
if ((loc = strstr_rs(line, "terminate=")) != 0) {
strcpy (amf_comp->terminate_cmd, loc);
} else
if ((loc = strstr_rs(line, "cleanup=")) != 0) {
strcpy (amf_comp->cleanup_cmd, loc);
} else
if ((loc = strstr_rs(line, "am_start=")) != 0) {
strcpy (amf_comp->am_start_cmd, loc);
} else
if ((loc = strstr_rs(line, "am_stop=")) != 0) {
strcpy (amf_comp->am_stop_cmd, loc);
} else
if ((loc = strstr_rs (line, "clccli_path=")) != 0) {
strcpy (amf_comp->clccli_path, loc);
} else
if ((loc = strstr_rs (line, "binary_path=")) != 0) {
strcpy (amf_comp->binary_path, loc);
} else
if ((loc = strstr_rs (line, "bn=")) != 0) {
strcpy (amf_comp->binary_name, loc);
} else
if (strstr_rs (line, "}")) {
current_parse = AMF_UNIT;
} else {
goto parse_error;
}
break;
case AMF_SERVICEINSTANCE:
if ((loc = strstr_rs (line, "name=")) != 0) {
setSaNameT (&amf_si->name, loc);
} else
if (strstr_rs (line, "}")) {
current_parse = AMF_GROUP;
} else {
goto parse_error;
}
break;
case AMF_HEALTHCHECK:
if ((loc = strstr_rs (line, "key=")) != 0) {
strcpy (amf_healthcheck->key.key, loc);
amf_healthcheck->key.keyLen = strlen (loc);
} else
if ((loc = strstr_rs (line, "period=")) != 0) {
amf_healthcheck->period = atoi (loc);
} else
if ((loc = strstr_rs (line, "maximum_duration=")) != 0) {
amf_healthcheck->maximum_duration = atoi (loc);
} else
if (strstr_rs (line, "}")) {
current_parse = AMF_HEAD;
} else {
goto parse_error;
}
break;
default:
printf ("Invalid state\n");
goto parse_error;
break;
}
}
fclose (fp);
return (0);
parse_error:
sprintf (error_string_response,
"parse error at /etc/groups.conf:%d.\n", line_number);
*error_string = error_string_response;
fclose (fp);
return (-1);
}
Reference in New Issue View Git Blame Copy Permalink