starlingx
/
ha
Code Issues Proposed changes
ha/service-mgmt/sm-common-1.0.0/src/sm_types.c

1867 lines
77 KiB
C
Raw Blame History

//
// Copyright (c) 2014-2018 Wind River Systems, Inc.
//
// SPDX-License-Identifier: Apache-2.0
//
#include "sm_types.h"
#include <stdint.h>
#include <string.h>
#include <glib.h>
#include <arpa/inet.h>
#include "sm_limits.h"
#include "sm_debug.h"
#define SM_VALUE_STR_MAPPING_MAX_CHAR 128
typedef struct
{
int value;
char str[SM_VALUE_STR_MAPPING_MAX_CHAR];
} SmValueStrMappingT;
static SmValueStrMappingT
_sm_node_admin_state_mappings[SM_NODE_ADMIN_STATE_MAX] =
{
{ SM_NODE_ADMIN_STATE_NIL, "nil" },
{ SM_NODE_ADMIN_STATE_UNKNOWN, "unknown" },
{ SM_NODE_ADMIN_STATE_LOCKED, "locked" },
{ SM_NODE_ADMIN_STATE_UNLOCKED, "unlocked" },
};
static SmValueStrMappingT
_sm_node_oper_state_mappings[SM_NODE_OPERATIONAL_STATE_MAX] =
{
{ SM_NODE_OPERATIONAL_STATE_NIL, "nil" },
{ SM_NODE_OPERATIONAL_STATE_UNKNOWN, "unknown" },
{ SM_NODE_OPERATIONAL_STATE_ENABLED, "enabled" },
{ SM_NODE_OPERATIONAL_STATE_DISABLED, "disabled" },
};
static SmValueStrMappingT
_sm_node_avail_status_mappings[SM_NODE_AVAIL_STATUS_MAX] =
{
{ SM_NODE_AVAIL_STATUS_NIL, "nil" },
{ SM_NODE_AVAIL_STATUS_UNKNOWN, "unknown" },
{ SM_NODE_AVAIL_STATUS_NONE, "" },
{ SM_NODE_AVAIL_STATUS_AVAILABLE, "available" },
{ SM_NODE_AVAIL_STATUS_DEGRADED, "degraded" },
{ SM_NODE_AVAIL_STATUS_FAILED, "failed" },
};
static SmValueStrMappingT
_sm_node_ready_state_mappings[SM_NODE_READY_STATE_MAX] =
{
{ SM_NODE_READY_STATE_NIL, "nil" },
{ SM_NODE_READY_STATE_UNKNOWN, "unknown" },
{ SM_NODE_READY_STATE_ENABLED, "enabled" },
{ SM_NODE_READY_STATE_DISABLED, "disabled" },
};
static SmValueStrMappingT
_sm_node_event_mappings[SM_NODE_EVENT_MAX] =
{
{ SM_NODE_EVENT_NIL, "nil" },
{ SM_NODE_EVENT_UNKNOWN, "unknown" },
{ SM_NODE_EVENT_ENABLED, "enabled" },
{ SM_NODE_EVENT_DISABLED, "disabled" },
{ SM_NODE_EVENT_AUDIT, "audit" },
};
static SmValueStrMappingT
_sm_interface_state_mappings[SM_INTERFACE_STATE_MAX] =
{
{ SM_INTERFACE_STATE_NIL, "nil" },
{ SM_INTERFACE_STATE_UNKNOWN, "unknown" },
{ SM_INTERFACE_STATE_ENABLED, "enabled" },
{ SM_INTERFACE_STATE_DISABLED, "disabled" },
{ SM_INTERFACE_STATE_NOT_IN_USE, "not-in-use" }
};
static SmValueStrMappingT
_sm_network_type_mappings[SM_NETWORK_TYPE_MAX] =
{
{ SM_NETWORK_TYPE_NIL, "nil" },
{ SM_NETWORK_TYPE_UNKNOWN, "unknown" },
{ SM_NETWORK_TYPE_IPV4, "ipv4" },
{ SM_NETWORK_TYPE_IPV6, "ipv6" },
{ SM_NETWORK_TYPE_IPV4_UDP, "ipv4-udp" },
{ SM_NETWORK_TYPE_IPV6_UDP, "ipv6-udp" },
};
static SmValueStrMappingT
_sm_path_type_mappings[SM_PATH_TYPE_MAX] =
{
{ SM_PATH_TYPE_NIL, "nil" },
{ SM_PATH_TYPE_UNKNOWN, "unknown" },
{ SM_PATH_TYPE_PRIMARY, "primary" },
{ SM_PATH_TYPE_SECONDARY, "secondary" },
{ SM_PATH_TYPE_STATUS_ONLY, "status-only" },
};
static SmValueStrMappingT
_sm_auth_type_mappings[SM_AUTH_TYPE_MAX] =
{
{ SM_AUTH_TYPE_NIL, "nil" },
{ SM_AUTH_TYPE_UNKNOWN, "unknown" },
{ SM_AUTH_TYPE_NONE, "none" },
{ SM_AUTH_TYPE_HMAC_SHA512, "hmac-sha512" },
};
static SmValueStrMappingT
_sm_orchestration_type_mappings[SM_ORCHESTRATION_TYPE_MAX] =
{
{ SM_ORCHESTRATION_TYPE_NIL, "nil" },
{ SM_ORCHESTRATION_TYPE_UNKNOWN, "unknown" },
{ SM_ORCHESTRATION_TYPE_GEOGRAPHICAL, "geographical" },
{ SM_ORCHESTRATION_TYPE_REGIONAL, "regional" },
{ SM_ORCHESTRATION_TYPE_HYBRID, "hybrid" },
};
static SmValueStrMappingT
_sm_designation_type_mappings[SM_DESIGNATION_TYPE_MAX] =
{
{ SM_DESIGNATION_TYPE_NIL, "nil" },
{ SM_DESIGNATION_TYPE_UNKNOWN, "unknown" },
{ SM_DESIGNATION_TYPE_LEADER, "leader" },
{ SM_DESIGNATION_TYPE_BACKUP, "backup" },
{ SM_DESIGNATION_TYPE_OTHER, "other" },
};
static SmValueStrMappingT
_sm_service_domain_state_mappings[SM_SERVICE_DOMAIN_STATE_MAX] =
{
{ SM_SERVICE_DOMAIN_STATE_NIL, "nil" },
{ SM_SERVICE_DOMAIN_STATE_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_STATE_INITIAL, "initial" },
{ SM_SERVICE_DOMAIN_STATE_WAITING, "waiting" },
{ SM_SERVICE_DOMAIN_STATE_LEADER, "leader" },
{ SM_SERVICE_DOMAIN_STATE_BACKUP, "backup" },
{ SM_SERVICE_DOMAIN_STATE_OTHER, "other" },
};
static SmValueStrMappingT
_sm_service_domain_event_mappings[SM_SERVICE_DOMAIN_EVENT_MAX] =
{
{ SM_SERVICE_DOMAIN_EVENT_NIL, "nil" },
{ SM_SERVICE_DOMAIN_EVENT_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_EVENT_HELLO_MSG, "hello-message" },
{ SM_SERVICE_DOMAIN_EVENT_NEIGHBOR_AGEOUT, "neighbor-ageout" },
{ SM_SERVICE_DOMAIN_EVENT_INTERFACE_ENABLED, "interface-enabled" },
{ SM_SERVICE_DOMAIN_EVENT_INTERFACE_DISABLED, "interface-disabled" },
{ SM_SERVICE_DOMAIN_EVENT_WAIT_EXPIRED, "wait-expired" },
{ SM_SERVICE_DOMAIN_EVENT_CHANGING_LEADER, "change-leader" },
};
static SmValueStrMappingT
_sm_service_domain_interface_event_mappings[SM_SERVICE_DOMAIN_INTERFACE_EVENT_MAX] =
{
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_NIL, "nil" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_NODE_ENABLED, "node-enabled" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_NODE_DISABLED, "node-disabled" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_ENABLED, "enabled" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_DISABLED, "disabled" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_AUDIT, "audit" },
{ SM_SERVICE_DOMAIN_INTERFACE_EVENT_NOT_IN_USE, "not-in-use" }
};
static SmValueStrMappingT
_sm_failover_event_mappings[SM_FAILOVER_EVENT_MAX] =
{
{SM_FAILOVER_EVENT_HEARTBEAT_ENABLED, "heartbeat-enabled"},
{SM_FAILOVER_EVENT_IF_STATE_CHANGED, "interface-state-changed"},
{SM_FAILOVER_EVENT_FAIL_PENDING_TIMEOUT, "fail-pending-timeout"},
{SM_FAILOVER_EVENT_NODE_ENABLED, "node-enabled"}
};
static SmValueStrMappingT
_sm_failover_state_mappings[SM_FAILOVER_STATE_MAX] =
{
{SM_FAILOVER_STATE_INITIAL, "initial"},
{SM_FAILOVER_STATE_NORMAL, "normal"},
{SM_FAILOVER_STATE_FAIL_PENDING, "fail-pending"},
{SM_FAILOVER_STATE_FAILED, "failed"},
{SM_FAILOVER_STATE_SURVIVED, "survived"}
};
static SmValueStrMappingT
_sm_service_domain_neighbor_state_mappings[SM_SERVICE_DOMAIN_NEIGHBOR_STATE_MAX] =
{
{ SM_SERVICE_DOMAIN_NEIGHBOR_STATE_NIL, "nil" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_STATE_DOWN, "down" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_STATE_EXCHANGE_START, "exchange-start" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_STATE_EXCHANGE, "exchange" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_STATE_FULL, "full" },
};
static SmValueStrMappingT
_sm_service_domain_neighbor_event_mappings[SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_MAX] =
{
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_NIL, "nil" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_HELLO_MSG, "hello-message" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_EXCHANGE_START_MSG, "exchange-start-message" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_EXCHANGE_START_TIMER, "exchange-start-timer" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_EXCHANGE_MSG, "exchange-message" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_EXCHANGE_TIMEOUT, "exchange-timeout" },
{ SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_DOWN, "down" },
};
static SmValueStrMappingT
_sm_service_domain_member_redundancy_model_mappings[SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_MAX] =
{
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_NIL, "nil" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_NONE, "none" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_N, "N" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_N_PLUS_M, "N + M" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_N_TO_1, "N to 1" },
{ SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_N_TO_N, "N to N" },
};
static SmValueStrMappingT
_sm_service_domain_split_brain_recovery_mappings[SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_MAX] =
{
{ SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_NIL, "nil" },
{ SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_DISABLE_ALL_ACTIVE, "disable-all-active" },
{ SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_SELECT_BEST_ACTIVE, "select-best-active" },
};
static SmValueStrMappingT
_sm_service_group_action_mappings[SM_SERVICE_GROUP_ACTION_MAX] =
{
{ SM_SERVICE_GROUP_ACTION_NIL, "nil" },
{ SM_SERVICE_GROUP_ACTION_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_ACTION_DISABLE, "disable" },
{ SM_SERVICE_GROUP_ACTION_GO_ACTIVE, "go-active" },
{ SM_SERVICE_GROUP_ACTION_GO_STANDBY, "go-standby" },
{ SM_SERVICE_GROUP_ACTION_AUDIT, "audit" },
{ SM_SERVICE_GROUP_ACTION_RECOVER, "recover" },
};
static SmValueStrMappingT
_sm_service_group_state_mappings[SM_SERVICE_GROUP_STATE_MAX] =
{
{ SM_SERVICE_GROUP_STATE_NIL, "nil" },
{ SM_SERVICE_GROUP_STATE_NA, "not-applicable" },
{ SM_SERVICE_GROUP_STATE_INITIAL, "initial" },
{ SM_SERVICE_GROUP_STATE_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_STATE_STANDBY, "standby" },
{ SM_SERVICE_GROUP_STATE_GO_STANDBY, "go-standby" },
{ SM_SERVICE_GROUP_STATE_GO_ACTIVE, "go-active" },
{ SM_SERVICE_GROUP_STATE_ACTIVE, "active" },
{ SM_SERVICE_GROUP_STATE_DISABLING, "disabling" },
{ SM_SERVICE_GROUP_STATE_DISABLED, "disabled" },
{ SM_SERVICE_GROUP_STATE_SHUTDOWN, "shutdown" },
};
static SmValueStrMappingT
_sm_service_group_event_mappings[SM_SERVICE_GROUP_EVENT_MAX] =
{
{ SM_SERVICE_GROUP_EVENT_NIL, "nil" },
{ SM_SERVICE_GROUP_EVENT_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_EVENT_GO_ACTIVE, "go-active" },
{ SM_SERVICE_GROUP_EVENT_GO_STANDBY, "go-standby" },
{ SM_SERVICE_GROUP_EVENT_DISABLE, "disable" },
{ SM_SERVICE_GROUP_EVENT_AUDIT, "audit" },
{ SM_SERVICE_GROUP_EVENT_SERVICE_SCN, "service-state-change" },
{ SM_SERVICE_GROUP_EVENT_SHUTDOWN, "shutdown" },
{ SM_SERVICE_GROUP_EVENT_NOTIFICATION_SUCCESS, "notification-success" },
{ SM_SERVICE_GROUP_EVENT_NOTIFICATION_FAILED, "notification-failed" },
{ SM_SERVICE_GROUP_EVENT_NOTIFICATION_TIMEOUT, "notification-timeout" },
};
static SmValueStrMappingT
_sm_service_group_status_mappings[SM_SERVICE_GROUP_STATUS_MAX] =
{
{ SM_SERVICE_GROUP_STATUS_NIL, "nil" },
{ SM_SERVICE_GROUP_STATUS_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_STATUS_NONE, "" },
{ SM_SERVICE_GROUP_STATUS_WARN, "warn" },
{ SM_SERVICE_GROUP_STATUS_DEGRADED, "degraded" },
{ SM_SERVICE_GROUP_STATUS_FAILED, "failed" },
};
static SmValueStrMappingT
_sm_service_group_condition_mappings[SM_SERVICE_GROUP_CONDITION_MAX] =
{
{ SM_SERVICE_GROUP_CONDITION_NIL, "nil" },
{ SM_SERVICE_GROUP_CONDITION_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_CONDITION_NONE, "" },
{ SM_SERVICE_GROUP_CONDITION_DATA_INCONSISTENT, "data-inconsistent" },
{ SM_SERVICE_GROUP_CONDITION_DATA_OUTDATED, "data-outdated" },
{ SM_SERVICE_GROUP_CONDITION_DATA_CONSISTENT, "data-consistent" },
{ SM_SERVICE_GROUP_CONDITION_DATA_SYNC, "data-syncing" },
{ SM_SERVICE_GROUP_CONDITION_DATA_STANDALONE, "data-standalone" },
{ SM_SERVICE_GROUP_CONDITION_RECOVERY_FAILURE, "recovery-failure" },
{ SM_SERVICE_GROUP_CONDITION_ACTION_FAILURE, "action-failure" },
{ SM_SERVICE_GROUP_CONDITION_FATAL_FAILURE, "fatal-failure" },
};
static SmValueStrMappingT
_sm_service_group_notification_mappings[SM_SERVICE_GROUP_NOTIFICATION_MAX] =
{
{ SM_SERVICE_GROUP_NOTIFICATION_NIL, "nil" },
{ SM_SERVICE_GROUP_NOTIFICATION_UNKNOWN, "unknown" },
{ SM_SERVICE_GROUP_NOTIFICATION_STANDBY, "standby" },
{ SM_SERVICE_GROUP_NOTIFICATION_GO_STANDBY, "go-standby" },
{ SM_SERVICE_GROUP_NOTIFICATION_GO_ACTIVE, "go-active" },
{ SM_SERVICE_GROUP_NOTIFICATION_ACTIVE, "active" },
{ SM_SERVICE_GROUP_NOTIFICATION_DISABLING, "disabling" },
{ SM_SERVICE_GROUP_NOTIFICATION_DISABLED, "disabled" },
{ SM_SERVICE_GROUP_NOTIFICATION_SHUTDOWN, "shutdown" },
};
static SmValueStrMappingT
_sm_service_admin_state_mappings[SM_SERVICE_ADMIN_STATE_MAX] =
{
{ SM_SERVICE_ADMIN_STATE_NIL, "nil" },
{ SM_SERVICE_ADMIN_STATE_NA, "not-applicable" },
{ SM_SERVICE_ADMIN_STATE_LOCKED, "initial" },
{ SM_SERVICE_ADMIN_STATE_UNLOCKED, "unknown" },
};
static SmValueStrMappingT
_sm_service_state_mappings[SM_SERVICE_STATE_MAX] =
{
{ SM_SERVICE_STATE_NIL, "nil" },
{ SM_SERVICE_STATE_NA, "not-applicable" },
{ SM_SERVICE_STATE_INITIAL, "initial" },
{ SM_SERVICE_STATE_UNKNOWN, "unknown" },
{ SM_SERVICE_STATE_ENABLED_STANDBY, "enabled-standby" },
{ SM_SERVICE_STATE_ENABLED_GO_STANDBY, "enabled-go-standby" },
{ SM_SERVICE_STATE_ENABLED_GO_ACTIVE, "enabled-go-active" },
{ SM_SERVICE_STATE_ENABLED_ACTIVE, "enabled-active" },
{ SM_SERVICE_STATE_ENABLING, "enabling" },
{ SM_SERVICE_STATE_ENABLING_THROTTLE, "enabling-throttle" },
{ SM_SERVICE_STATE_DISABLING, "disabling" },
{ SM_SERVICE_STATE_DISABLED, "disabled" },
{ SM_SERVICE_STATE_SHUTDOWN, "shutdown" },
};
static SmValueStrMappingT
_sm_service_event_mappings[SM_SERVICE_EVENT_MAX] =
{
{ SM_SERVICE_EVENT_NIL, "nil" },
{ SM_SERVICE_EVENT_UNKNOWN, "unknown" },
{ SM_SERVICE_EVENT_ENABLE_THROTTLE, "enable-throttle" },
{ SM_SERVICE_EVENT_ENABLE, "enable" },
{ SM_SERVICE_EVENT_ENABLE_SUCCESS, "enable-success" },
{ SM_SERVICE_EVENT_ENABLE_FAILED, "enable-failed" },
{ SM_SERVICE_EVENT_ENABLE_TIMEOUT, "enable-timeout" },
{ SM_SERVICE_EVENT_GO_ACTIVE, "go-active" },
{ SM_SERVICE_EVENT_GO_ACTIVE_SUCCESS, "go-active-success" },
{ SM_SERVICE_EVENT_GO_ACTIVE_FAILED, "go-active-failed" },
{ SM_SERVICE_EVENT_GO_ACTIVE_TIMEOUT, "go-active-timeout" },
{ SM_SERVICE_EVENT_GO_STANDBY, "go-standby" },
{ SM_SERVICE_EVENT_GO_STANDBY_SUCCESS, "go-standby-success" },
{ SM_SERVICE_EVENT_GO_STANDBY_FAILED, "go-standby-failed" },
{ SM_SERVICE_EVENT_GO_STANDBY_TIMEOUT, "go-standby-timeout" },
{ SM_SERVICE_EVENT_DISABLE, "disable" },
{ SM_SERVICE_EVENT_DISABLE_SUCCESS, "disable-success" },
{ SM_SERVICE_EVENT_DISABLE_FAILED, "disable-failed" },
{ SM_SERVICE_EVENT_DISABLE_TIMEOUT, "disable-timeout" },
{ SM_SERVICE_EVENT_AUDIT, "audit" },
{ SM_SERVICE_EVENT_AUDIT_SUCCESS, "audit-success" },
{ SM_SERVICE_EVENT_AUDIT_FAILED, "audit-failed" },
{ SM_SERVICE_EVENT_AUDIT_TIMEOUT, "audit-timeout" },
{ SM_SERVICE_EVENT_AUDIT_MISMATCH, "audit-mismatch" },
{ SM_SERVICE_EVENT_HEARTBEAT_OKAY, "heartbeat-okay" },
{ SM_SERVICE_EVENT_HEARTBEAT_WARN, "heartbeat-warn" },
{ SM_SERVICE_EVENT_HEARTBEAT_DEGRADE, "heartbeat-degrade" },
{ SM_SERVICE_EVENT_HEARTBEAT_FAIL, "heartbeat-fail" },
{ SM_SERVICE_EVENT_PROCESS_FAILURE, "process-failure" },
{ SM_SERVICE_EVENT_SHUTDOWN, "shutdown" },
};
static SmValueStrMappingT
_sm_service_status_mappings[SM_SERVICE_STATUS_MAX] =
{
{ SM_SERVICE_STATUS_NIL, "nil" },
{ SM_SERVICE_STATUS_UNKNOWN, "unknown" },
{ SM_SERVICE_STATUS_NONE, "" },
{ SM_SERVICE_STATUS_WARN, "warn" },
{ SM_SERVICE_STATUS_DEGRADED, "degraded" },
{ SM_SERVICE_STATUS_FAILED, "failed" },
};
static SmValueStrMappingT
_sm_service_condition_mappings[SM_SERVICE_CONDITION_MAX] =
{
{ SM_SERVICE_CONDITION_NIL, "nil" },
{ SM_SERVICE_CONDITION_UNKNOWN, "unknown" },
{ SM_SERVICE_CONDITION_NONE, "" },
// Degraded Conditions.
{ SM_SERVICE_CONDITION_DATA_INCONSISTENT, "data-inconsistent" },
{ SM_SERVICE_CONDITION_DATA_OUTDATED, "data-outdated" },
{ SM_SERVICE_CONDITION_DATA_CONSISTENT, "data-consistent" },
{ SM_SERVICE_CONDITION_DATA_SYNC, "data-syncing" },
{ SM_SERVICE_CONDITION_DATA_STANDALONE, "data-standalone" },
// Failed Conditions.
{ SM_SERVICE_CONDITION_RECOVERY_FAILURE, "recovery-failure" },
{ SM_SERVICE_CONDITION_ACTION_FAILURE, "action-failure" },
{ SM_SERVICE_CONDITION_FATAL_FAILURE, "fatal-failure" },
};
static SmValueStrMappingT
_sm_service_severity_mappings[SM_SERVICE_SEVERITY_MAX] =
{
{ SM_SERVICE_SEVERITY_NIL, "nil" },
{ SM_SERVICE_SEVERITY_UNKNOWN, "unknown" },
{ SM_SERVICE_SEVERITY_NONE, "none" },
{ SM_SERVICE_SEVERITY_MINOR, "minor" },
{ SM_SERVICE_SEVERITY_MAJOR, "major" },
{ SM_SERVICE_SEVERITY_CRITICAL, "critical" },
};
static SmValueStrMappingT
_sm_service_heartbeat_type_mappings[SM_SERVICE_HEARTBEAT_TYPE_MAX] =
{
{ SM_SERVICE_HEARTBEAT_TYPE_NIL, "nil" },
{ SM_SERVICE_HEARTBEAT_TYPE_UNKNOWN, "unknown" },
{ SM_SERVICE_HEARTBEAT_TYPE_UNIX, "unix" },
{ SM_SERVICE_HEARTBEAT_TYPE_UDP, "udp" },
};
static SmValueStrMappingT
_sm_service_heartbeat_state_mappings[SM_SERVICE_HEARTBEAT_STATE_MAX] =
{
{ SM_SERVICE_HEARTBEAT_STATE_NIL, "nil" },
{ SM_SERVICE_HEARTBEAT_STATE_UNKNOWN, "unknown" },
{ SM_SERVICE_HEARTBEAT_STATE_STARTED, "started" },
{ SM_SERVICE_HEARTBEAT_STATE_STOPPED, "stopped" },
};
static SmValueStrMappingT
_sm_service_dependency_type_mappings[SM_SERVICE_DEPENDENCY_TYPE_MAX] =
{
{ SM_SERVICE_DEPENDENCY_TYPE_NIL, "nil" },
{ SM_SERVICE_DEPENDENCY_TYPE_UNKNOWN, "unknown" },
{ SM_SERVICE_DEPENDENCY_TYPE_ACTION, "action" },
{ SM_SERVICE_DEPENDENCY_TYPE_STATE, "state" },
};
static SmValueStrMappingT
_sm_service_action_mappings[SM_SERVICE_ACTION_MAX] =
{
{ SM_SERVICE_ACTION_NIL, "nil" },
{ SM_SERVICE_ACTION_NA, "not-applicable" },
{ SM_SERVICE_ACTION_UNKNOWN, "unknown" },
{ SM_SERVICE_ACTION_NONE, "none" },
{ SM_SERVICE_ACTION_ENABLE, "enable" },
{ SM_SERVICE_ACTION_DISABLE, "disable" },
{ SM_SERVICE_ACTION_GO_ACTIVE, "go-active" },
{ SM_SERVICE_ACTION_GO_STANDBY, "go-standby" },
{ SM_SERVICE_ACTION_AUDIT_ENABLED, "audit-enabled" },
{ SM_SERVICE_ACTION_AUDIT_DISABLED, "audit-disabled" },
};
static SmValueStrMappingT
_sm_service_action_result_mappings[SM_SERVICE_ACTION_RESULT_MAX] =
{
{ SM_SERVICE_ACTION_RESULT_NIL, "nil" },
{ SM_SERVICE_ACTION_RESULT_UNKNOWN, "unknown" },
{ SM_SERVICE_ACTION_RESULT_SUCCESS, "success" },
{ SM_SERVICE_ACTION_RESULT_FATAL, "fatal" },
{ SM_SERVICE_ACTION_RESULT_FAILED, "failed" },
{ SM_SERVICE_ACTION_RESULT_TIMEOUT, "timeout" },
};
static SmValueStrMappingT
_sm_service_domain_scheduling_state_mappings[SM_SERVICE_DOMAIN_SCHEDULING_STATE_MAX] =
{
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_NIL, "nil" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_UNKNOWN, "unknown" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_NONE, "none" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_SWACT, "swact" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_SWACT_FORCE, "swact-force" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_DISABLE, "disable" },
{ SM_SERVICE_DOMAIN_SCHEDULING_STATE_DISABLE_FORCE, "disable-force" },
};
static SmValueStrMappingT
_sm_service_domain_scheduling_list_mappings[] =
{
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_NIL, "nil" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_ACTIVE, "active" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_GO_ACTIVE, "go-active" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_GO_STANDBY, "go-standby" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_STANDBY, "standby" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_DISABLING, "disabling" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_DISABLED, "disabled" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_FAILED, "failed" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_FATAL, "fatal" },
{ SM_SERVICE_DOMAIN_SCHEDULING_LIST_UNAVAILABLE, "unavailable" },
};
static SmValueStrMappingT _sm_error_mappings[SM_ERROR_MAX] =
{
{ SM_OKAY, "OKAY" },
{ SM_NOT_FOUND, "NOT_FOUND" },
{ SM_NO_MSG, "NO_MSG" },
{ SM_NOT_IMPLEMENTED, "NOT_IMPLEMENTED" },
{ SM_FAILED, "FAILED" },
};
typedef struct
{
SmNodeAdminStateT admin_state;
SmNodeReadyStateT ready_state;
char str[SM_VALUE_STR_MAPPING_MAX_CHAR];
} SmNodeStateStrMappingT;
static SmNodeStateStrMappingT
_sm_node_state_mappings[SM_NODE_ADMIN_STATE_MAX*SM_NODE_READY_STATE_MAX] =
{
{ SM_NODE_ADMIN_STATE_NIL, SM_NODE_READY_STATE_NIL, "nil-nil" },
{ SM_NODE_ADMIN_STATE_NIL, SM_NODE_READY_STATE_UNKNOWN, "nil-unknown" },
{ SM_NODE_ADMIN_STATE_NIL, SM_NODE_READY_STATE_ENABLED, "nil-enabled" },
{ SM_NODE_ADMIN_STATE_NIL, SM_NODE_READY_STATE_DISABLED, "nil-disabled" },
{ SM_NODE_ADMIN_STATE_UNKNOWN, SM_NODE_READY_STATE_NIL, "unknown-nil" },
{ SM_NODE_ADMIN_STATE_UNKNOWN, SM_NODE_READY_STATE_UNKNOWN, "unknown-unknown" },
{ SM_NODE_ADMIN_STATE_UNKNOWN, SM_NODE_READY_STATE_ENABLED, "unknown-enabled" },
{ SM_NODE_ADMIN_STATE_UNKNOWN, SM_NODE_READY_STATE_DISABLED, "unknown-disabled" },
{ SM_NODE_ADMIN_STATE_LOCKED, SM_NODE_READY_STATE_NIL, "locked-nil" },
{ SM_NODE_ADMIN_STATE_LOCKED, SM_NODE_READY_STATE_UNKNOWN, "locked-unknown" },
{ SM_NODE_ADMIN_STATE_LOCKED, SM_NODE_READY_STATE_ENABLED, "locked-enabled" },
{ SM_NODE_ADMIN_STATE_LOCKED, SM_NODE_READY_STATE_DISABLED, "locked-disabled" },
{ SM_NODE_ADMIN_STATE_UNLOCKED, SM_NODE_READY_STATE_NIL, "unlocked-nil" },
{ SM_NODE_ADMIN_STATE_UNLOCKED, SM_NODE_READY_STATE_UNKNOWN, "unlocked-unknown" },
{ SM_NODE_ADMIN_STATE_UNLOCKED, SM_NODE_READY_STATE_ENABLED, "unlocked-enabled" },
{ SM_NODE_ADMIN_STATE_UNLOCKED, SM_NODE_READY_STATE_DISABLED, "unlocked-disabled" },
};
static SmValueStrMappingT _sm_system_mode_mapping[SM_SYSTEM_MODE_MAX] =
{
{ SM_SYSTEM_MODE_UNKNOWN, "UNKNOWN" },
{ SM_SYSTEM_MODE_STANDARD, "standard" },
{ SM_SYSTEM_MODE_CPE_DUPLEX, "duplex" },
{ SM_SYSTEM_MODE_CPE_DUPLEX_DC, "duplex-direct" },
{ SM_SYSTEM_MODE_CPE_SIMPLEX, "simplex" },
};
static SmValueStrMappingT
_sm_node_schedule_state_mappings[SM_NODE_STATE_MAX] =
{
{ SM_NODE_STATE_UNKNOWN, "unknown" },
{ SM_NODE_STATE_ACTIVE, "active" },
{ SM_NODE_STATE_STANDBY, "standby" },
{ SM_NODE_STATE_INIT, "init" },
{ SM_NODE_STATE_FAILED, "failed" }
};
// ****************************************************************************
// Types - Mapping Get String
// ==========================
static const char* sm_mapping_get_str( SmValueStrMappingT mappings[],
unsigned int num_mappings, int value )
{
unsigned int map_i;
for( map_i=0; num_mappings > map_i; ++map_i )
{
if( value == mappings[map_i].value )
{
return( &(mappings[map_i].str[0]) );
}
}
return( "???" );
}
// ****************************************************************************
// ****************************************************************************
// Types - Mapping Get Value
// =========================
static int sm_mapping_get_value( SmValueStrMappingT mappings[],
unsigned int num_mappings, const char* str )
{
unsigned int map_i;
for( map_i=0; num_mappings > map_i; ++map_i )
{
if( 0 == strcmp( &(mappings[map_i].str[0]), str ) )
{
return( mappings[map_i].value );
}
}
return( 0 );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Administrative State Value
// =======================================
SmNodeAdminStateT sm_node_admin_state_value( const char* state_str )
{
return( (SmNodeAdminStateT)
sm_mapping_get_value( _sm_node_admin_state_mappings,
SM_NODE_ADMIN_STATE_MAX,
state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Administrative State String
// ========================================
const char* sm_node_admin_state_str( SmNodeAdminStateT state )
{
return( sm_mapping_get_str( _sm_node_admin_state_mappings,
SM_NODE_ADMIN_STATE_MAX,
state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Operational State Value
// ====================================
SmNodeOperationalStateT sm_node_oper_state_value( const char* state_str )
{
return( (SmNodeOperationalStateT)
sm_mapping_get_value( _sm_node_oper_state_mappings,
SM_NODE_OPERATIONAL_STATE_MAX,
state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Operational State String
// =====================================
const char* sm_node_oper_state_str( SmNodeOperationalStateT state )
{
return( sm_mapping_get_str( _sm_node_oper_state_mappings,
SM_NODE_OPERATIONAL_STATE_MAX,
state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Availability Status Value
// ======================================
SmNodeAvailStatusT sm_node_avail_status_value( const char* status_str )
{
return( (SmNodeAvailStatusT)
sm_mapping_get_value( _sm_node_avail_status_mappings,
SM_NODE_AVAIL_STATUS_MAX,
status_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Availability Status String
// =======================================
const char* sm_node_avail_status_str( SmNodeAvailStatusT status )
{
return( sm_mapping_get_str( _sm_node_avail_status_mappings,
SM_NODE_AVAIL_STATUS_MAX,
status ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Ready State Value
// ==============================
SmNodeReadyStateT sm_node_ready_state_value( const char* state_str )
{
return( (SmNodeReadyStateT)
sm_mapping_get_value( _sm_node_ready_state_mappings,
SM_NODE_READY_STATE_MAX,
state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Ready State String
// ===============================
const char* sm_node_ready_state_str( SmNodeReadyStateT state )
{
return( sm_mapping_get_str( _sm_node_ready_state_mappings,
SM_NODE_READY_STATE_MAX,
state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node State String
// =========================
const char* sm_node_state_str( SmNodeAdminStateT admin_state,
SmNodeReadyStateT ready_state )
{
unsigned int map_i;
for( map_i=0; (SM_NODE_ADMIN_STATE_MAX*SM_NODE_READY_STATE_MAX) > map_i;
++map_i )
{
if(( admin_state == _sm_node_state_mappings[map_i].admin_state )&&
( ready_state == _sm_node_state_mappings[map_i].ready_state ))
{
return( &(_sm_node_state_mappings[map_i].str[0]) );
}
}
return( "???" );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Event Value
// ========================
SmNodeEventT sm_node_event_value( const char* event_str )
{
return( (SmNodeEventT)
sm_mapping_get_value( _sm_node_event_mappings,
SM_NODE_EVENT_MAX, event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Node Event String
// =========================
const char* sm_node_event_str( SmNodeEventT event )
{
return( sm_mapping_get_str( _sm_node_event_mappings,
SM_NODE_EVENT_MAX, event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Interface State Value
// =============================
SmInterfaceStateT sm_interface_state_value( const char* state_str )
{
return( (SmInterfaceStateT)
sm_mapping_get_value( _sm_interface_state_mappings,
SM_INTERFACE_STATE_MAX, state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Interface State String
// ==============================
const char* sm_interface_state_str( SmInterfaceStateT state )
{
return( sm_mapping_get_str( _sm_interface_state_mappings,
SM_INTERFACE_STATE_MAX, state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Network Type Value
// ==========================
SmNetworkTypeT sm_network_type_value( const char* network_type_str )
{
return( (SmNetworkTypeT)
sm_mapping_get_value( _sm_network_type_mappings,
SM_NETWORK_TYPE_MAX, network_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Network Type String
// ===========================
const char* sm_network_type_str( SmNetworkTypeT network_type )
{
return( sm_mapping_get_str( _sm_network_type_mappings,
SM_NETWORK_TYPE_MAX, network_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Path Type Value
// =======================
SmPathTypeT sm_path_type_value( const char* path_type_str )
{
return( (SmPathTypeT)
sm_mapping_get_value( _sm_path_type_mappings,
SM_PATH_TYPE_MAX, path_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Path Type String
// ========================
const char* sm_path_type_str( SmPathTypeT path_type )
{
return( sm_mapping_get_str( _sm_path_type_mappings,
SM_PATH_TYPE_MAX, path_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Authentication Type Value
// =================================
SmAuthTypeT sm_auth_type_value( const char* auth_type_str )
{
return( (SmAuthTypeT)
sm_mapping_get_value( _sm_auth_type_mappings,
SM_AUTH_TYPE_MAX, auth_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Authentication Type String
// ==================================
const char* sm_auth_type_str( SmAuthTypeT auth_type )
{
return( sm_mapping_get_str( _sm_auth_type_mappings,
SM_AUTH_TYPE_MAX, auth_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Orchestration Type Value
// ================================
SmOrchestrationTypeT sm_orchestration_type_value(
const char* orchestration_type_str )
{
return( (SmOrchestrationTypeT)
sm_mapping_get_value( _sm_orchestration_type_mappings,
SM_ORCHESTRATION_TYPE_MAX,
orchestration_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Orchestration Type String
// =================================
const char* sm_orchestration_type_str( SmOrchestrationTypeT orchestration_type )
{
return( sm_mapping_get_str( _sm_orchestration_type_mappings,
SM_ORCHESTRATION_TYPE_MAX,
orchestration_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Designation Type Value
// ==============================
SmDesignationTypeT sm_designation_type_value(
const char* designation_type_str )
{
return( (SmDesignationTypeT)
sm_mapping_get_value( _sm_designation_type_mappings,
SM_DESIGNATION_TYPE_MAX,
designation_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Designation Type String
// ===============================
const char* sm_designation_type_str( SmDesignationTypeT designation_type )
{
return( sm_mapping_get_str( _sm_designation_type_mappings,
SM_DESIGNATION_TYPE_MAX, designation_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain State Value
// ==================================
SmServiceDomainStateT sm_service_domain_state_value( const char* state_str )
{
return( (SmServiceDomainStateT)
sm_mapping_get_value( _sm_service_domain_state_mappings,
SM_SERVICE_DOMAIN_STATE_MAX, state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain State String
// ===================================
const char* sm_service_domain_state_str( SmServiceDomainStateT state )
{
return( sm_mapping_get_str( _sm_service_domain_state_mappings,
SM_SERVICE_DOMAIN_STATE_MAX, state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Event Value
// ==================================
SmServiceDomainEventT sm_service_domain_event_value( const char* event_str )
{
return( (SmServiceDomainEventT)
sm_mapping_get_value( _sm_service_domain_event_mappings,
SM_SERVICE_DOMAIN_EVENT_MAX, event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Event String
// ===================================
const char* sm_service_domain_event_str( SmServiceDomainEventT event )
{
return( sm_mapping_get_str( _sm_service_domain_event_mappings,
SM_SERVICE_DOMAIN_EVENT_MAX, event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Scheduling State Value
// =============================================
SmServiceDomainSchedulingStateT sm_service_domain_scheduling_state_value(
const char* sched_state_str )
{
return( (SmServiceDomainSchedulingStateT)
sm_mapping_get_value( _sm_service_domain_scheduling_state_mappings,
SM_SERVICE_DOMAIN_SCHEDULING_STATE_MAX,
sched_state_str ) );
}
// ****************************************************************************
// ***************************************************************************
// Types - Service Domain Scheduling State String
// ==============================================
const char* sm_service_domain_scheduling_state_str(
SmServiceDomainSchedulingStateT sched_state )
{
return( sm_mapping_get_str( _sm_service_domain_scheduling_state_mappings,
SM_SERVICE_DOMAIN_SCHEDULING_STATE_MAX,
sched_state ) );
}
// ***************************************************************************
// ****************************************************************************
// Types - Service Domain Scheduling List Value
// ============================================
SmServiceDomainSchedulingListT sm_service_domain_scheduling_list_value(
const char* sched_list_str )
{
return( (SmServiceDomainSchedulingListT)
sm_mapping_get_value( _sm_service_domain_scheduling_list_mappings,
SM_SERVICE_DOMAIN_SCHEDULING_LIST_MAX,
sched_list_str ) );
}
// ****************************************************************************
// ***************************************************************************
// Types - Service Domain Scheduling List String
// =============================================
const char* sm_service_domain_scheduling_list_str(
SmServiceDomainSchedulingListT sched_list )
{
return( sm_mapping_get_str( _sm_service_domain_scheduling_list_mappings,
SM_SERVICE_DOMAIN_SCHEDULING_LIST_MAX,
sched_list ) );
}
// ***************************************************************************
// ****************************************************************************
// Types - Service Domain Interface Event Value
// ============================================
SmServiceDomainInterfaceEventT sm_service_domain_interface_event_value(
const char* event_str )
{
return( (SmServiceDomainInterfaceEventT)
sm_mapping_get_value( _sm_service_domain_interface_event_mappings,
SM_SERVICE_DOMAIN_INTERFACE_EVENT_MAX,
event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Interface Event String
// =============================================
const char* sm_service_domain_interface_event_str(
SmServiceDomainInterfaceEventT event )
{
return( sm_mapping_get_str( _sm_service_domain_interface_event_mappings,
SM_SERVICE_DOMAIN_INTERFACE_EVENT_MAX,
event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Failover Event String
// =============================================
const char* sm_failover_event_str( SmFailoverEventT event )
{
return( sm_mapping_get_str( _sm_failover_event_mappings,
SM_FAILOVER_EVENT_MAX,
event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Failover State String
// =============================================
const char* sm_failover_state_str( SmFailoverStateT state )
{
return( sm_mapping_get_str( _sm_failover_state_mappings,
SM_FAILOVER_STATE_MAX,
state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Neighbor State Value
// ===========================================
SmServiceDomainNeighborStateT sm_service_domain_neighbor_state_value(
const char* neighbor_state_str )
{
return( (SmServiceDomainNeighborStateT)
sm_mapping_get_value( _sm_service_domain_neighbor_state_mappings,
SM_SERVICE_DOMAIN_NEIGHBOR_STATE_MAX,
neighbor_state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Neighbor State String
// ============================================
const char* sm_service_domain_neighbor_state_str(
SmServiceDomainNeighborStateT neighbor_state )
{
return( sm_mapping_get_str( _sm_service_domain_neighbor_state_mappings,
SM_SERVICE_DOMAIN_NEIGHBOR_STATE_MAX,
neighbor_state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Neighbor Event Value
// ===========================================
SmServiceDomainNeighborEventT sm_service_domainneighbor_event_value(
const char* neighbor_event_str )
{
return( (SmServiceDomainNeighborEventT)
sm_mapping_get_value( _sm_service_domain_neighbor_event_mappings,
SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_MAX,
neighbor_event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Neighbor Event String
// ============================================
const char* sm_service_domain_neighbor_event_str(
SmServiceDomainNeighborEventT neighbor_event )
{
return( sm_mapping_get_str( _sm_service_domain_neighbor_event_mappings,
SM_SERVICE_DOMAIN_NEIGHBOR_EVENT_MAX,
neighbor_event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Member Redundancy Model Value
// ====================================================
SmServiceDomainMemberRedundancyModelT sm_service_domain_member_redundancy_model_value(
const char* model_str )
{
return( (SmServiceDomainMemberRedundancyModelT)
sm_mapping_get_value( _sm_service_domain_member_redundancy_model_mappings,
SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_MAX,
model_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Member Redundancy Model String
// =====================================================
const char* sm_service_domain_member_redundancy_model_str(
SmServiceDomainMemberRedundancyModelT model )
{
return( sm_mapping_get_str( _sm_service_domain_member_redundancy_model_mappings,
SM_SERVICE_DOMAIN_MEMBER_REDUNDANCY_MODEL_MAX,
model ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Split Brain Recovery Value
// =================================================
SmServiceDomainSplitBrainRecoveryT sm_service_domain_split_brain_recovery_value(
const char* recovery_str )
{
return( (SmServiceDomainSplitBrainRecoveryT)
sm_mapping_get_value( _sm_service_domain_split_brain_recovery_mappings,
SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_MAX,
recovery_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Domain Split Brain Recovery String
// ==================================================
const char* sm_service_domain_split_brain_recovery_str(
SmServiceDomainSplitBrainRecoveryT recovery )
{
return( sm_mapping_get_str( _sm_service_domain_split_brain_recovery_mappings,
SM_SERVICE_DOMAIN_SPLIT_BRAIN_RECOVERY_MAX,
recovery ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Action Value
// ==================================
SmServiceGroupActionT sm_service_group_action_value(
const char* action_str )
{
return( (SmServiceGroupActionT)
sm_mapping_get_value( _sm_service_group_action_mappings,
SM_SERVICE_GROUP_ACTION_MAX, action_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Action String
// ===================================
const char* sm_service_group_action_str( SmServiceGroupActionT action )
{
return( sm_mapping_get_str( _sm_service_group_action_mappings,
SM_SERVICE_GROUP_ACTION_MAX, action ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group State Value
// =================================
SmServiceGroupStateT sm_service_group_state_value(
const char* state_str )
{
return( (SmServiceGroupStateT)
sm_mapping_get_value( _sm_service_group_state_mappings,
SM_SERVICE_GROUP_STATE_MAX, state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group State String
// ==================================
const char* sm_service_group_state_str( SmServiceGroupStateT state )
{
return( sm_mapping_get_str( _sm_service_group_state_mappings,
SM_SERVICE_GROUP_STATE_MAX, state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group State Lesser Value
// ========================================
SmServiceGroupStateT sm_service_group_state_lesser(
SmServiceGroupStateT state_a, SmServiceGroupStateT state_b )
{
SmServiceGroupStateT lesser_state = SM_SERVICE_GROUP_STATE_UNKNOWN;
switch( state_a )
{
case SM_SERVICE_GROUP_STATE_NIL:
lesser_state = state_b;
break;
case SM_SERVICE_GROUP_STATE_INITIAL:
if( SM_SERVICE_GROUP_STATE_NIL == state_b )
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_UNKNOWN:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_DISABLED:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_DISABLING:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLED == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_STANDBY:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLING == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLED == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_GO_ACTIVE:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLING == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLED == state_b )||
( SM_SERVICE_GROUP_STATE_STANDBY == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_GO_STANDBY:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLING == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLED == state_b )||
( SM_SERVICE_GROUP_STATE_STANDBY == state_b )||
( SM_SERVICE_GROUP_STATE_GO_ACTIVE == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_GROUP_STATE_ACTIVE:
if(( SM_SERVICE_GROUP_STATE_NIL == state_b )||
( SM_SERVICE_GROUP_STATE_INITIAL == state_b )||
( SM_SERVICE_GROUP_STATE_UNKNOWN == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLING == state_b )||
( SM_SERVICE_GROUP_STATE_DISABLED == state_b )||
( SM_SERVICE_GROUP_STATE_STANDBY == state_b )||
( SM_SERVICE_GROUP_STATE_GO_ACTIVE == state_b )||
( SM_SERVICE_GROUP_STATE_GO_STANDBY == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
default:
DPRINTFE( "Unknown state (%s) given.",
sm_service_group_state_str( state_a ) );
break;
}
return( lesser_state );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Event Value
// =================================
SmServiceGroupEventT sm_service_group_event_value( const char* event_str )
{
return( (SmServiceGroupEventT)
sm_mapping_get_value( _sm_service_group_event_mappings,
SM_SERVICE_GROUP_EVENT_MAX, event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Event String
// ==================================
const char* sm_service_group_event_str( SmServiceGroupEventT event )
{
return( sm_mapping_get_str( _sm_service_group_event_mappings,
SM_SERVICE_GROUP_EVENT_MAX, event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Status Value
// ==================================
SmServiceGroupStatusT sm_service_group_status_value(
const char* status_str )
{
return( (SmServiceGroupStatusT)
sm_mapping_get_value( _sm_service_group_status_mappings,
SM_SERVICE_GROUP_STATUS_MAX, status_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Status String
// ===================================
const char* sm_service_group_status_str( SmServiceGroupStatusT status )
{
return( sm_mapping_get_str( _sm_service_group_status_mappings,
SM_SERVICE_GROUP_STATUS_MAX, status ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Condition Value
// =====================================
SmServiceGroupConditionT sm_service_group_condition_value(
const char* condition_str )
{
return( (SmServiceGroupConditionT)
sm_mapping_get_value( _sm_service_group_condition_mappings,
SM_SERVICE_GROUP_CONDITION_MAX,
condition_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Condition String
// ======================================
const char* sm_service_group_condition_str( SmServiceGroupConditionT condition )
{
return( sm_mapping_get_str( _sm_service_group_condition_mappings,
SM_SERVICE_GROUP_CONDITION_MAX, condition ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Notification Value
// ========================================
SmServiceGroupNotificationT sm_service_group_notification_value(
const char* notification_str )
{
return( (SmServiceGroupNotificationT)
sm_mapping_get_value( _sm_service_group_notification_mappings,
SM_SERVICE_GROUP_NOTIFICATION_MAX,
notification_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Group Notification String
// =========================================
const char* sm_service_group_notification_str(
SmServiceGroupNotificationT notification )
{
return( sm_mapping_get_str( _sm_service_group_notification_mappings,
SM_SERVICE_GROUP_NOTIFICATION_MAX,
notification ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Admin State Value
// =================================
SmServiceAdminStateT sm_service_admin_state_value( const char* state_str )
{
return( (SmServiceAdminStateT)
sm_mapping_get_value( _sm_service_admin_state_mappings,
SM_SERVICE_ADMIN_STATE_MAX, state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Admin State String
// ==================================
const char* sm_service_admin_state_str( SmServiceAdminStateT state )
{
return( sm_mapping_get_str( _sm_service_admin_state_mappings,
SM_SERVICE_ADMIN_STATE_MAX, state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service State Value
// ===========================
SmServiceStateT sm_service_state_value( const char* state_str )
{
return( (SmServiceStateT)
sm_mapping_get_value( _sm_service_state_mappings,
SM_SERVICE_STATE_MAX, state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service State String
// ============================
const char* sm_service_state_str( SmServiceStateT state )
{
return( sm_mapping_get_str( _sm_service_state_mappings,
SM_SERVICE_STATE_MAX, state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service State Lesser Value
// ==================================
SmServiceStateT sm_service_state_lesser( SmServiceStateT state_a,
SmServiceStateT state_b )
{
SmServiceStateT lesser_state = SM_SERVICE_STATE_UNKNOWN;
switch( state_a )
{
case SM_SERVICE_STATE_NIL:
lesser_state = state_b;
break;
case SM_SERVICE_STATE_INITIAL:
if( SM_SERVICE_STATE_NIL == state_b )
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_UNKNOWN:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_DISABLED:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_ENABLING:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_ENABLING_THROTTLE == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_DISABLING:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b )||
( SM_SERVICE_STATE_ENABLING == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_ENABLED_STANDBY:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_ENABLING_THROTTLE == state_b )||
( SM_SERVICE_STATE_ENABLING == state_b )||
( SM_SERVICE_STATE_DISABLING == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_ENABLED_GO_ACTIVE:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_ENABLING_THROTTLE == state_b )||
( SM_SERVICE_STATE_ENABLING == state_b )||
( SM_SERVICE_STATE_DISABLING == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b )||
( SM_SERVICE_STATE_ENABLED_STANDBY == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_ENABLED_GO_STANDBY:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_ENABLING_THROTTLE == state_b )||
( SM_SERVICE_STATE_ENABLING == state_b )||
( SM_SERVICE_STATE_DISABLING == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b )||
( SM_SERVICE_STATE_ENABLED_STANDBY == state_b )||
( SM_SERVICE_STATE_ENABLED_GO_ACTIVE == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
case SM_SERVICE_STATE_ENABLED_ACTIVE:
if(( SM_SERVICE_STATE_NIL == state_b )||
( SM_SERVICE_STATE_INITIAL == state_b )||
( SM_SERVICE_STATE_UNKNOWN == state_b )||
( SM_SERVICE_STATE_ENABLING_THROTTLE == state_b )||
( SM_SERVICE_STATE_ENABLING == state_b )||
( SM_SERVICE_STATE_DISABLING == state_b )||
( SM_SERVICE_STATE_DISABLED == state_b )||
( SM_SERVICE_STATE_ENABLED_STANDBY == state_b )||
( SM_SERVICE_STATE_ENABLED_GO_ACTIVE == state_b )||
( SM_SERVICE_STATE_ENABLED_GO_STANDBY == state_b ))
{
lesser_state = state_b;
} else {
lesser_state = state_a;
}
break;
default:
DPRINTFE( "Unknown state (%s) given.",
sm_service_state_str( state_a ) );
break;
}
return( lesser_state );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Event Value
// ===========================
SmServiceEventT sm_service_event_value( const char* event_str )
{
return( (SmServiceEventT)
sm_mapping_get_value( _sm_service_event_mappings,
SM_SERVICE_EVENT_MAX, event_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Event String
// ============================
const char* sm_service_event_str( SmServiceEventT event )
{
return( sm_mapping_get_str( _sm_service_event_mappings,
SM_SERVICE_EVENT_MAX, event ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Status Value
// ============================
SmServiceStatusT sm_service_status_value( const char* status_str )
{
return( (SmServiceStatusT)
sm_mapping_get_value( _sm_service_status_mappings,
SM_SERVICE_STATUS_MAX, status_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Status String
// =============================
const char* sm_service_status_str( SmServiceStatusT status )
{
return( sm_mapping_get_str( _sm_service_status_mappings,
SM_SERVICE_STATUS_MAX, status ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Condition Value
// ===============================
SmServiceConditionT sm_service_condition_value( const char* condition_str )
{
return( (SmServiceConditionT)
sm_mapping_get_value( _sm_service_condition_mappings,
SM_SERVICE_CONDITION_MAX, condition_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Condition String
// ================================
const char* sm_service_condition_str( SmServiceConditionT condition )
{
return( sm_mapping_get_str( _sm_service_condition_mappings,
SM_SERVICE_CONDITION_MAX, condition ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Severity Value
// ==============================
SmServiceSeverityT sm_service_severity_value( const char* severity_str )
{
return( (SmServiceSeverityT)
sm_mapping_get_value( _sm_service_severity_mappings,
SM_SERVICE_SEVERITY_MAX, severity_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Severity String
// ===============================
const char* sm_service_severity_str( SmServiceSeverityT severity )
{
return( sm_mapping_get_str( _sm_service_severity_mappings,
SM_SERVICE_SEVERITY_MAX, severity ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Heartbeat Type Value
// ====================================
SmServiceHeartbeatTypeT sm_service_heartbeat_type_value(
const char* heartbeat_type_str )
{
return( (SmServiceHeartbeatTypeT)
sm_mapping_get_value( _sm_service_heartbeat_type_mappings,
SM_SERVICE_HEARTBEAT_TYPE_MAX,
heartbeat_type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Heartbeat Type String
// =====================================
const char* sm_service_heartbeat_type_str(
SmServiceHeartbeatTypeT heartbeat_type )
{
return( sm_mapping_get_str( _sm_service_heartbeat_type_mappings,
SM_SERVICE_HEARTBEAT_TYPE_MAX,
heartbeat_type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Heartbeat State Value
// =====================================
SmServiceHeartbeatStateT sm_service_heartbeat_state_value(
const char* heartbeat_state_str )
{
return( (SmServiceHeartbeatStateT)
sm_mapping_get_value( _sm_service_heartbeat_state_mappings,
SM_SERVICE_HEARTBEAT_STATE_MAX,
heartbeat_state_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Heartbeat State String
// ======================================
const char* sm_service_heartbeat_state_str(
SmServiceHeartbeatStateT heartbeat_state )
{
return( sm_mapping_get_str( _sm_service_heartbeat_state_mappings,
SM_SERVICE_HEARTBEAT_STATE_MAX,
heartbeat_state ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Dependency Type Value
// =====================================
SmServiceDependencyTypeT sm_service_dependency_type_value(
const char* type_str )
{
return( (SmServiceDependencyTypeT)
sm_mapping_get_value( _sm_service_dependency_type_mappings,
SM_SERVICE_DEPENDENCY_TYPE_MAX, type_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Dependency Type String
// ======================================
const char* sm_service_dependency_type_str( SmServiceDependencyTypeT type )
{
return( sm_mapping_get_str( _sm_service_dependency_type_mappings,
SM_SERVICE_DEPENDENCY_TYPE_MAX, type ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Action Value
// ============================
SmServiceActionT sm_service_action_value( const char* action_str )
{
return( (SmServiceActionT)
sm_mapping_get_value( _sm_service_action_mappings,
SM_SERVICE_ACTION_MAX, action_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Action String
// =============================
const char* sm_service_action_str( SmServiceActionT action )
{
return( sm_mapping_get_str( _sm_service_action_mappings,
SM_SERVICE_ACTION_MAX, action ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Action Result Value
// ===================================
SmServiceActionResultT sm_service_action_result_value( const char* result_str )
{
return( (SmServiceActionResultT)
sm_mapping_get_value( _sm_service_action_result_mappings,
SM_SERVICE_ACTION_RESULT_MAX, result_str ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Service Action Result String
// ====================================
const char* sm_service_action_result_str( SmServiceActionResultT result )
{
return( sm_mapping_get_str( _sm_service_action_result_mappings,
SM_SERVICE_ACTION_RESULT_MAX, result ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - Network Address Value
// =============================
bool sm_network_address_value( const char address_str[],
SmNetworkAddressT* address )
{
int result = 0;
if( NULL == address )
{
return false;
}
if(( SM_NETWORK_TYPE_IPV4 == address->type )||
( SM_NETWORK_TYPE_IPV4_UDP == address->type ))
{
result = inet_pton( AF_INET, address_str, &(address->u.ipv4.sin) );
} else if(( SM_NETWORK_TYPE_IPV6 == address->type )||
( SM_NETWORK_TYPE_IPV6_UDP == address->type ))
{
result = inet_pton( AF_INET6, address_str, &(address->u.ipv6.sin6) );
} else {
DPRINTFD( "Unsupported network address type (%s).",
sm_network_type_str( address->type ) );
}
if( 0 >= result )
{
memset( address, 0, sizeof(SmNetworkAddressT) );
return false;
}
return true;
}
// ****************************************************************************
// ****************************************************************************
// Types - Network Address String
// ==============================
void sm_network_address_str( const SmNetworkAddressT* address,
char address_str[] )
{
address_str[0] = '\0';
if( NULL != address )
{
const char* result = NULL;
if(( SM_NETWORK_TYPE_IPV4 == address->type )||
( SM_NETWORK_TYPE_IPV4_UDP == address->type ))
{
result = inet_ntop( AF_INET, &(address->u.ipv4.sin),
address_str, SM_NETWORK_ADDRESS_MAX_CHAR );
} else if(( SM_NETWORK_TYPE_IPV6 == address->type )||
( SM_NETWORK_TYPE_IPV6_UDP == address->type ))
{
result = inet_ntop( AF_INET6, &(address->u.ipv6.sin6),
address_str, SM_NETWORK_ADDRESS_MAX_CHAR );
} else {
DPRINTFD( "Unsupported network address type (%s).",
sm_network_type_str( address->type ) );
}
if( NULL == result )
{
address_str[0] = '\0';
}
}
}
// ****************************************************************************
// ****************************************************************************
// Types - Error String
// ====================
const char* sm_error_str( SmErrorT error )
{
return( sm_mapping_get_str( _sm_error_mappings, SM_ERROR_MAX, error ) );
}
// ****************************************************************************
// ****************************************************************************
// Types - System Mode String
// =======================================
const char* sm_system_mode_str( SmSystemModeT system_mode)
{
return( sm_mapping_get_str(_sm_system_mode_mapping, SM_SYSTEM_MODE_MAX, system_mode) );
}
// ****************************************************************************
// ****************************************************************************
// Service Domain Interface Type
// =====================================
SmInterfaceTypeT sm_get_interface_type( const char* domain_interface )
{
if ( 0 == strcmp ( SM_SERVICE_DOMAIN_MGMT_INTERFACE, domain_interface ) )
{
return SM_INTERFACE_MGMT;
} else if ( 0 == strcmp ( SM_SERVICE_DOMAIN_OAM_INTERFACE, domain_interface ) )
{
return SM_INTERFACE_OAM;
} else if ( 0 == strcmp ( SM_SERVICE_DOMAIN_INFRA_INTERFACE, domain_interface ) )
{
return SM_INTERFACE_INFRA;
}
return SM_INTERFACE_UNKNOWN;
}
// ****************************************************************************
// ****************************************************************************
// node schedule state
// =====================================
const char* sm_node_schedule_state_str( SmNodeScheduleStateT state )
{
return( sm_mapping_get_str(_sm_node_schedule_state_mappings, SM_NODE_STATE_MAX, state) );
}
// ****************************************************************************
View Git Blame Copy Permalink