starlingx/metal
Code Issues Proposed changes

Merge "Add 50 byte hostname support to maintenance"

Browse Source
This commit is contained in:
Zuul 2019-07-12 14:35:24 +00:00 committed by Gerrit Code Review
commit 1bf45bdb27
19 changed files with 915 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
mtce-common/src/common/msgClass.cpp
View File

@ -309,17 +309,17 @@ int msgClassAddr::getAddressFromInterface(const char* interface, char* address,
return rc; return rc;
} }
} }
char hostname[MAX_HOST_NAME_SIZE+1] = {0}; char hostname[MAX_CHARS_HOSTNAME] = {0};
if (gethostname(hostname, if (gethostname(hostname, MAX_CHARS_HOSTNAME) < 0)
MAX_HOST_NAME_SIZE) < 0) { {
elog("Failed to get system host name (err: %d)", errno); elog("Failed to gethostname (%d:%m)", errno);
return rc; return rc;
} }
// if hostname is localhost then resolution will give us // if hostname is localhost then resolution will give us
// the interface loopback address. Detect this case and // the interface loopback address. Detect this case and
// return. // return.
if (!strncmp(hostname, "localhost", 9)) { if (!strcmp(hostname, LOCALHOST)) {
wlog ("Detected localhost as system hostname." wlog ("Detected localhost as system hostname."
" Cannot resolve IP address"); " Cannot resolve IP address");
return rc; return rc;
@ -328,19 +328,17 @@ int msgClassAddr::getAddressFromInterface(const char* interface, char* address,
// if it is cluster-host then we need to determine the interface // if it is cluster-host then we need to determine the interface
// host name. For management interface, the system hostname // host name. For management interface, the system hostname
// is the intf hostname // is the intf hostname
const char* cluster_host_suffix = "-cluster-host"; char iface_hostname[MAX_CHARS_HOSTNAME];
size_t cluster_host_suffix_len = sizeof(cluster_host_suffix);
char iface_hostname[MAX_HOST_NAME_SIZE+cluster_host_suffix_len];
memset(iface_hostname, 0, sizeof(iface_hostname)); memset(iface_hostname, 0, sizeof(iface_hostname));
snprintf(iface_hostname, sizeof(iface_hostname), snprintf(iface_hostname, sizeof(iface_hostname),
"%s%s", hostname, "%s%s", hostname,
(((interface_type == CLSTR_IFACE)) ? cluster_host_suffix : "")); (((interface_type == CLSTR_IFACE)) ? CLUSTER_HOST_SUFFIX : ""));
struct addrinfo *res = NULL; struct addrinfo *res = NULL;
int ret = getaddrinfo(iface_hostname, NULL, NULL, &res); int ret = getaddrinfo(iface_hostname, NULL, NULL, &res);
if(ret) if(ret)
{ {
elog("IP address resolution failed for %s (err: %s)", elog("%s ip address resolution failed (err: %s)",
iface_hostname, gai_strerror(ret)); iface_hostname, gai_strerror(ret));
return rc; return rc;
} }

50
mtce-common/src/common/nlEvent.cpp
View File

@ -165,8 +165,8 @@ int get_netlink_events ( int nl_socket , std::list<string> & links_gone_down,
void log_link_events ( int netlink_sock, void log_link_events ( int netlink_sock,
int ioctl_sock, int ioctl_sock,
const char * mgmnt_iface_ptr, const char * mgmnt_iface_ptr,
const char * clstr_iface_ptr, const char * clstr_iface_ptr,
bool & mgmnt_link_up_and_running, bool & mgmnt_link_up_and_running,
bool & clstr_link_up_and_running) bool & clstr_link_up_and_running)
@ -175,28 +175,28 @@ void log_link_events ( int netlink_sock,
std::list<string> links_gone_up ; std::list<string> links_gone_up ;
std::list<string>::iterator iter_curr_ptr ; std::list<string>::iterator iter_curr_ptr ;
dlog3 ("logging for interfaces %s and %s\n", mgmnt_iface_ptr, clstr_iface_ptr); dlog3 ("logging for interfaces %s and %s\n", mgmnt_iface_ptr, clstr_iface_ptr);
if ( get_netlink_events ( netlink_sock, links_gone_down, links_gone_up )) if ( get_netlink_events ( netlink_sock, links_gone_down, links_gone_up ))
{ {
bool running = false ; bool running = false ;
if ( !links_gone_down.empty() ) if ( !links_gone_down.empty() )
{ {
dlog3 ("%ld links have dropped\n", links_gone_down.size() ); dlog3 ("%ld links have dropped\n", links_gone_down.size() );
/* Look at the down list */ /* Look at the down list */
for ( iter_curr_ptr = links_gone_down.begin(); for ( iter_curr_ptr = links_gone_down.begin();
iter_curr_ptr != links_gone_down.end() ; iter_curr_ptr != links_gone_down.end() ;
iter_curr_ptr++ ) iter_curr_ptr++ )
{ {
dlog3 ( "downed link: %s (running:%d:%d)\n", dlog3 ( "downed link: %s (running:%d:%d)\n",
iter_curr_ptr->c_str(), iter_curr_ptr->c_str(),
mgmnt_link_up_and_running, mgmnt_link_up_and_running,
clstr_link_up_and_running ); clstr_link_up_and_running );
if ( !strcmp (mgmnt_iface_ptr, iter_curr_ptr->data())) if ( !strcmp (mgmnt_iface_ptr, iter_curr_ptr->data()))
{ {
if ( mgmnt_link_up_and_running == true ) if ( mgmnt_link_up_and_running == true )
{ {
mgmnt_link_up_and_running = false ; mgmnt_link_up_and_running = false ;
wlog ("Mgmnt link %s is down\n", mgmnt_iface_ptr ); wlog ("Mgmnt link %s is down\n", mgmnt_iface_ptr );
} }
} }
@ -208,14 +208,19 @@ void log_link_events ( int netlink_sock,
wlog ("Cluster-host link %s is down\n", clstr_iface_ptr ); wlog ("Cluster-host link %s is down\n", clstr_iface_ptr );
} }
} }
if ( get_link_state ( ioctl_sock, iter_curr_ptr->data(), &running ) == PASS ) if ( get_link_state ( ioctl_sock, iter_curr_ptr->data(), &running ) == PASS )
{ {
dlog ("%s is down (oper:%s)\n", iter_curr_ptr->c_str(), running ? "up" : "down" ); wlog ("%s is down (oper:%s) (%ld)\n",
iter_curr_ptr->c_str(),
running ? "up" : "down",
iter_curr_ptr->length() );
} }
else else
{ {
wlog ("%s is down (driver query failed)\n", iter_curr_ptr->c_str() ); wlog ("%s is down (driver query failed) (len:%ld)\n",
iter_curr_ptr->c_str(),
iter_curr_ptr->length() );
} }
} }
} }
@ -228,14 +233,14 @@ void log_link_events ( int netlink_sock,
iter_curr_ptr != links_gone_up.end() ; iter_curr_ptr != links_gone_up.end() ;
iter_curr_ptr++ ) iter_curr_ptr++ )
{ {
dlog3 ( "recovered link: %s (running:%d:%d)\n", dlog3 ( "recovered link: %s (running:%d:%d)\n",
iter_curr_ptr->c_str(), iter_curr_ptr->c_str(),
mgmnt_link_up_and_running, mgmnt_link_up_and_running,
clstr_link_up_and_running ); clstr_link_up_and_running );
if ( !strcmp (mgmnt_iface_ptr, iter_curr_ptr->data())) if ( !strcmp (mgmnt_iface_ptr, iter_curr_ptr->data()))
{ {
mgmnt_link_up_and_running = true ; mgmnt_link_up_and_running = true ;
wlog ("Mgmnt link %s is up\n", mgmnt_iface_ptr ); wlog ("Mgmnt link %s is up\n", mgmnt_iface_ptr );
} }
if ( !strcmp (clstr_iface_ptr, iter_curr_ptr->data())) if ( !strcmp (clstr_iface_ptr, iter_curr_ptr->data()))
@ -246,13 +251,16 @@ void log_link_events ( int netlink_sock,
if ( get_link_state ( ioctl_sock, iter_curr_ptr->data(), &running ) == PASS ) if ( get_link_state ( ioctl_sock, iter_curr_ptr->data(), &running ) == PASS )
{ {
dlog ("%s is up (oper:%s)\n", wlog ("%s is up (oper:%s) (len:%ld)\n",
iter_curr_ptr->c_str(), iter_curr_ptr->c_str(),
running ? "up" : "down" ); running ? "up" : "down",
iter_curr_ptr->length() );
} }
else else
{ {
wlog ("%s is up (driver query failed)\n", iter_curr_ptr->c_str() ); wlog ("%s is up (driver query failed) (len:%ld)\n",
iter_curr_ptr->c_str(),
iter_curr_ptr->length() );
} }
} }
} }
@ -291,9 +299,9 @@ int open_netlink_socket ( int groups )
addr.nl_pid = getpid (); addr.nl_pid = getpid ();
/* addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR; */ /* addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR; */
addr.nl_groups = groups ; /* allow the caller to specify the groups */ addr.nl_groups = groups ; /* allow the caller to specify the groups */
if (bind (nl_socket, (struct sockaddr *) &addr, sizeof (addr)) < 0) if (bind (nl_socket, (struct sockaddr *) &addr, sizeof (addr)) < 0)
{ {
elog ( "Failed to bind netlink socket (%d:%s)\n", errno, strerror(errno)); elog ( "Failed to bind netlink socket (%d:%s)\n", errno, strerror(errno));
close (nl_socket); close (nl_socket);
nl_socket = 0 ; nl_socket = 0 ;

2
mtce-common/src/common/nodeBase.cpp
View File

@ -194,7 +194,7 @@ const char * get_mtcNodeCommand_str ( int cmd )
case MTC_EVENT_HOST_STALLED: return("host stalled event"); case MTC_EVENT_HOST_STALLED: return("host stalled event");
/* pmon events */ /* pmon events */
case MTC_EVENT_PMON_CLEAR: return("pmon clear"); case MTC_EVENT_PMON_CLEAR: return("pmon degrade clear");
case MTC_EVENT_PMON_CRIT: return("pmon critical event"); case MTC_EVENT_PMON_CRIT: return("pmon critical event");
case MTC_EVENT_PMON_MAJOR: return("pmon major event"); case MTC_EVENT_PMON_MAJOR: return("pmon major event");
case MTC_EVENT_PMON_MINOR: return("pmon minor event"); case MTC_EVENT_PMON_MINOR: return("pmon minor event");

34
mtce-common/src/common/nodeBase.h
View File

@ -163,6 +163,9 @@ void daemon_exit ( void );
#define LOOPBACK_IPV6 "::1" #define LOOPBACK_IPV6 "::1"
#define LOCALHOST "localhost" #define LOCALHOST "localhost"
#define CLUSTER_HOST_SUFFIX ((const char*)("-cluster-host"))
#define NONE (const char *)"none" #define NONE (const char *)"none"
/** Largest heartbeat pulse (req/resp) message size */ /** Largest heartbeat pulse (req/resp) message size */
@ -198,8 +201,10 @@ void daemon_exit ( void );
#define MTC_JSON_INV_BMIP "bm_ip" #define MTC_JSON_INV_BMIP "bm_ip"
#define MTC_JSON_INV_BMTYPE "bm_type" #define MTC_JSON_INV_BMTYPE "bm_type"
#define MTC_JSON_INV_BMUN "bm_username" #define MTC_JSON_INV_BMUN "bm_username"
#define MTC_JSON_SERVICE "service"
#define MTC_JSON_SEVERITY "severity" #define MTC_JSON_SEVERITY "severity"
#define MTC_JSON_SENSOR "sensor"
#define MTC_JSON_PROCESS "process"
/* These Task strings should not be changed without /* These Task strings should not be changed without
* the corresponding change in Horizon. * the corresponding change in Horizon.
@ -336,9 +341,9 @@ void daemon_exit ( void );
/* root@controller-0:~# getconf HOST_NAME_MAX /* root@controller-0:~# getconf HOST_NAME_MAX
* 64 * 64
*/ */
#define MAX_CHARS_HOSTNAME (32) /**< The largest hostname length */ #define MAX_CHARS_HOSTNAME_32 (32)
// #define MAX_CHARS_HOSTNAME (64) /**< The largest hostname length */ #define MAX_CHARS_HOSTNAME (256) /**< the largest hostname length */
#define MAX_CHARS_FILENAME (256) /**< The largest hostname length */ #define MAX_CHARS_FILENAME (256) /**< the largest filename length */
#define MAX_CHARS_ON_LINE (256) /**> max number of chars on a single line */ #define MAX_CHARS_ON_LINE (256) /**> max number of chars on a single line */
#define MAX_CHARS_IN_INT (65) /**> max number of chars in an integer */ #define MAX_CHARS_IN_INT (65) /**> max number of chars in an integer */
@ -389,6 +394,26 @@ void daemon_exit ( void );
/* This label will resolve to an IP on the management network */ /* This label will resolve to an IP on the management network */
#define CONTROLLER_NFS ((const char *)"controller-nfs") #define CONTROLLER_NFS ((const char *)"controller-nfs")
/* Maintenance Daemon Services - actual names of the daemons */
/* ... controller only service / daemons */
#define MTC_SERVICE_MTCAGENT_NAME "mtcAgent"
#define MTC_SERVICE_HBSAGENT_NAME "hbsAgent"
#define MTC_SERVICE_HWMOND_NAME "hwmond"
#define MTC_SERVICE_GUESTAGENT_NAME "guestAgent"
/* ... all nodes services / daemons */
#define MTC_SERVICE_PMOND_NAME "pmond"
#define MTC_SERVICE_HBSCLIENT_NAME "hbsClient"
#define MTC_SERVICE_MTCCLIENT_NAME "mtcClient"
#define MTC_SERVICE_HOSTW_NAME "hostwd"
#define MTC_SERVICE_FSMON_NAME "fsmond"
#define MTC_SERVICE_LMON_NAME "lmond"
#define MTC_SERVICE_MTCLOG_NAME "mtclogd"
/* ... compute only services / daemons */
#define MTC_SERVICE_GUESTSERVER_NAME "guestServer"
#define CGTS_NODE_TYPES 4 #define CGTS_NODE_TYPES 4
#define CGTS_NODE_TYPE_SIZE 12 #define CGTS_NODE_TYPE_SIZE 12
#define CGTS_NODE_NULL (0x00) #define CGTS_NODE_NULL (0x00)
@ -499,6 +524,7 @@ const char * get_heartbeat_ready_header( void ) ;
#define MTC_CMD_REVISION (0) #define MTC_CMD_REVISION (0)
#define MTC_CMD_FEATURE_VER__MACADDR_IN_CMD (1) #define MTC_CMD_FEATURE_VER__MACADDR_IN_CMD (1)
#define MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF (2)
typedef struct typedef struct
{ {

3
mtce-common/src/common/nodeUtil.cpp
View File

@ -110,6 +110,7 @@ void node_inv_init (node_inv_type & inv)
inv.uuid.clear(); inv.uuid.clear();
inv.name.clear(); inv.name.clear();
inv.ip.clear(); inv.ip.clear();
inv.clstr_ip.clear();
inv.mac.clear(); inv.mac.clear();
inv.admin.clear(); inv.admin.clear();
inv.oper.clear(); inv.oper.clear();
@ -750,7 +751,7 @@ int get_iface_address ( const char * iface_ptr, string & ip_addr , bool retry )
if ( rc == PASS ) if ( rc == PASS )
{ {
ip_addr = ip_cstr; ip_addr = ip_cstr;
ilog ("IP Address : %s\n", ip_addr.c_str() ); dlog ("IP Address : %s\n", ip_addr.c_str() );
} }
else else
{ {

101
mtce/src/common/nodeClass.cpp
View File

@ -281,6 +281,7 @@ nodeLinkClass::nodeLinkClass()
my_hostname.clear() ; my_hostname.clear() ;
my_local_ip.clear() ; my_local_ip.clear() ;
my_float_ip.clear() ; my_float_ip.clear() ;
my_clstr_ip.clear() ;
active_controller_hostname.clear() ; active_controller_hostname.clear() ;
inactive_controller_hostname.clear() ; inactive_controller_hostname.clear() ;
@ -2351,15 +2352,15 @@ int nodeLinkClass::mod_host ( node_inv_type & inv )
} }
if ( node_ptr->clstr_ip.compare ( inv.clstr_ip ) ) if ( node_ptr->clstr_ip.compare ( inv.clstr_ip ) )
{ {
if (( hostUtil_is_valid_ip_addr ( inv.clstr_ip )) || ( hostUtil_is_valid_ip_addr ( node_ptr->clstr_ip ))) if ( hostUtil_is_valid_ip_addr ( inv.clstr_ip ))
{ {
plog ("%s Modify 'clstr_ip' from %s -> %s\n", plog ("%s Modify 'clstr_ip' from %s -> %s\n",
node_ptr->hostname.c_str(), node_ptr->hostname.c_str(),
node_ptr->clstr_ip.c_str(), inv.clstr_ip.c_str() ); node_ptr->clstr_ip.c_str(), inv.clstr_ip.c_str() );
modify = true ; /* we have a delta */ modify = true ; /* we have a delta */
node_ptr->clstr_ip = inv.clstr_ip ;
} }
node_ptr->clstr_ip = inv.clstr_ip ;
} }
if ( (!inv.name.empty()) && (node_ptr->hostname.compare ( inv.name)) ) if ( (!inv.name.empty()) && (node_ptr->hostname.compare ( inv.name)) )
{ {
@ -2976,10 +2977,13 @@ int nodeLinkClass::add_heartbeat_host ( const node_inv_type & inv )
/* Handle the case where we are adding a node that is already */ /* Handle the case where we are adding a node that is already */
/* present if so just update the inventory data not the mtc state */ /* present if so just update the inventory data not the mtc state */
node_ptr = nodeLinkClass::getNode(inv.name); node_ptr = nodeLinkClass::getNode(inv.name);
if ( node_ptr ) if ( node_ptr )
{ {
dlog ("%s already provisioned\n", node_ptr->hostname.c_str()); dlog ("%s already provisioned\n", node_ptr->hostname.c_str());
rc = RETRY ; node_ptr->nodetype = inv.nodetype ;
node_ptr->ip = inv.ip ;
node_ptr->clstr_ip = inv.clstr_ip ;
rc = PASS ;
} }
/* Otherwise add it as a new node */ /* Otherwise add it as a new node */
else else
@ -2989,6 +2993,8 @@ int nodeLinkClass::add_heartbeat_host ( const node_inv_type & inv )
{ {
node_ptr->hostname = inv.name ; node_ptr->hostname = inv.name ;
node_ptr->nodetype = inv.nodetype ; node_ptr->nodetype = inv.nodetype ;
node_ptr->ip = inv.ip ;
node_ptr->clstr_ip = inv.clstr_ip ;
dlog ("%s added to linked list\n", inv.name.c_str()); dlog ("%s added to linked list\n", inv.name.c_str());
rc = PASS ; rc = PASS ;
} }
@ -3323,21 +3329,32 @@ int nodeLinkClass::set_clstr_hostaddr ( string & hostname, string & ip )
node_ptr = nodeLinkClass::getNode ( hostname ); node_ptr = nodeLinkClass::getNode ( hostname );
if ( node_ptr != NULL ) if ( node_ptr != NULL )
{ {
node_ptr->clstr_ip = ip ; if (( hostUtil_is_valid_ip_addr(ip)) && ( node_ptr->clstr_ip != ip ))
{
ilog ("%s cluster address provision change from %s to %s",
hostname.c_str(),
node_ptr->clstr_ip.empty() ? "none" : node_ptr->clstr_ip.c_str(),
ip.c_str());
node_ptr->clstr_ip = ip ;
send_hbs_command ( node_ptr->hostname, MTC_CMD_MOD_HOST );
}
rc = PASS ; rc = PASS ;
} }
return ( rc ); return ( rc );
} }
string nodeLinkClass::get_hostname ( string & hostaddr ) string nodeLinkClass::get_hostname ( string hostaddr )
{ {
if (( hostaddr == LOOPBACK_IPV6 ) || if (( hostaddr == LOOPBACK_IPV6 ) ||
( hostaddr == LOOPBACK_IP ) || ( hostaddr == LOOPBACK_IP ) ||
( hostaddr == LOCALHOST )) ( hostaddr == LOCALHOST ) ||
( hostaddr == my_local_ip ) ||
( hostaddr == my_float_ip ) ||
( hostaddr == my_clstr_ip ))
{ {
return(my_hostname); return(this->my_hostname);
} }
else else if ( this->hosts )
{ {
nodeLinkClass::node* node_ptr ; nodeLinkClass::node* node_ptr ;
node_ptr = nodeLinkClass::getNode ( hostaddr ); node_ptr = nodeLinkClass::getNode ( hostaddr );
@ -3345,8 +3362,8 @@ string nodeLinkClass::get_hostname ( string & hostaddr )
{ {
return ( node_ptr->hostname ); return ( node_ptr->hostname );
} }
return ( null_str );
} }
return ( null_str );
} }
string nodeLinkClass::get_hostname_from_bm_ip ( string bm_ip ) string nodeLinkClass::get_hostname_from_bm_ip ( string bm_ip )
@ -4763,7 +4780,9 @@ int nodeLinkClass::declare_service_ready ( string & hostname,
else if ( service == MTC_SERVICE_PMOND ) else if ( service == MTC_SERVICE_PMOND )
{ {
node_ptr->pmond_ready = true ; node_ptr->pmond_ready = true ;
plog ("%s got pmond ready event\n", hostname.c_str()); plog ("%s %s ready event\n",
hostname.c_str(),
MTC_SERVICE_PMOND_NAME);
/* A ready event means that pmond pocess has started. /* A ready event means that pmond pocess has started.
* Any previous history is gone. Cleanup mtce. * Any previous history is gone. Cleanup mtce.
@ -4775,7 +4794,9 @@ int nodeLinkClass::declare_service_ready ( string & hostname,
else if ( service == MTC_SERVICE_HWMOND ) else if ( service == MTC_SERVICE_HWMOND )
{ {
node_ptr->hwmond_ready = true ; node_ptr->hwmond_ready = true ;
plog ("%s got hwmond ready event\n", hostname.c_str()); plog ("%s %s ready event\n",
hostname.c_str(),
MTC_SERVICE_HWMOND_NAME);
if ( node_ptr->bm_provisioned == true ) if ( node_ptr->bm_provisioned == true )
{ {
send_hwmon_command ( node_ptr->hostname, MTC_CMD_ADD_HOST ); send_hwmon_command ( node_ptr->hostname, MTC_CMD_ADD_HOST );
@ -4788,7 +4809,9 @@ int nodeLinkClass::declare_service_ready ( string & hostname,
if ( node_ptr->hbsClient_ready == false ) if ( node_ptr->hbsClient_ready == false )
{ {
node_ptr->hbsClient_ready = true ; node_ptr->hbsClient_ready = true ;
plog ("%s got hbsClient ready event\n", hostname.c_str()); plog ("%s %s ready event\n",
hostname.c_str(),
MTC_SERVICE_HBSCLIENT_NAME);
} }
return (PASS); return (PASS);
} }
@ -4901,7 +4924,7 @@ int nodeLinkClass::node_degrade_control ( string & hostname, int state, string s
slog ("%s service not specified", hostname.c_str()); slog ("%s service not specified", hostname.c_str());
return (FAIL_STRING_EMPTY); return (FAIL_STRING_EMPTY);
} }
else if ( !service.compare("hwmon") ) else if ( service == MTC_SERVICE_HWMOND_NAME )
{ {
service_flag = DEGRADE_MASK_HWMON ; service_flag = DEGRADE_MASK_HWMON ;
} }
@ -5048,6 +5071,9 @@ int nodeLinkClass::invoke_hwmon_action ( string & hostname, int action, string
mtcTimer_reset ( node_ptr->hwmon_reset.recovery_timer ); mtcTimer_reset ( node_ptr->hwmon_reset.recovery_timer );
mtcTimer_start ( node_ptr->hwmon_reset.recovery_timer, mtcTimer_handler, MTC_MINS_15 ); mtcTimer_start ( node_ptr->hwmon_reset.recovery_timer, mtcTimer_handler, MTC_MINS_15 );
wlog ("%s invoking 'reset' due to critical '%s' sensor assertion\n",
hostname.c_str(), sensor.c_str());
force_full_enable ( node_ptr ); force_full_enable ( node_ptr );
} }
else else
@ -7394,7 +7420,7 @@ bool nodeLinkClass::get_hwmond_monitor_state ( string & hostname )
{ {
bool state = false ; bool state = false ;
if ( hostname.length() ) if ( hostname.length() )
{ {
struct nodeLinkClass::node* node_ptr ; struct nodeLinkClass::node* node_ptr ;
node_ptr = nodeLinkClass::getNode ( hostname ); node_ptr = nodeLinkClass::getNode ( hostname );
if ( node_ptr != NULL ) if ( node_ptr != NULL )
@ -7419,9 +7445,14 @@ bool nodeLinkClass::get_hbs_monitor_state ( string & hostname, int iface )
state = node_ptr->monitor[iface] ; state = node_ptr->monitor[iface] ;
if ( state == true ) if ( state == true )
{ {
wlog_throttled (node_ptr->no_rri_log_throttle, rri_max, /* fast lookup not supported for hostnames longer than 31
"%s Not Offering RRI (%d)\n", * chars so in those cases don't do Not Offering RRI log */
hostname.c_str(), this->hosts ); if ( hostname.length() < MAX_CHARS_HOSTNAME_32 )
{
wlog_throttled (node_ptr->no_rri_log_throttle, rri_max,
"%s Not Offering RRI (hosts:%d)\n",
hostname.c_str(), this->hosts );
}
} }
else else
{ {
@ -7450,7 +7481,7 @@ void nodeLinkClass::manage_pulse_flags ( string & hostname, unsigned int flags )
/* Manage the heartbeat pulse flags by pulse_ptr */ /* Manage the heartbeat pulse flags by pulse_ptr */
void nodeLinkClass::manage_pulse_flags ( struct nodeLinkClass::node * node_ptr, unsigned int flags ) void nodeLinkClass::manage_pulse_flags ( struct nodeLinkClass::node * node_ptr, unsigned int flags )
{ {
/* Do nothing with the flags for missing pulse /* Do nothing with the flags for missing pulse
* responses (identified with flags=NULL_PULSE_FLAGS) */ * responses (identified with flags=NULL_PULSE_FLAGS) */
if ( flags == NULL_PULSE_FLAGS ) if ( flags == NULL_PULSE_FLAGS )
{ {
@ -7473,9 +7504,9 @@ void nodeLinkClass::manage_pulse_flags ( struct nodeLinkClass::node * node_ptr,
/* TODO: Does this need to be debounced ??? */ /* TODO: Does this need to be debounced ??? */
node_ptr->monitor[CLSTR_IFACE] = true ; node_ptr->monitor[CLSTR_IFACE] = true ;
} }
/* A host indicates that its process monitor is running by setting the /* A host indicates that its process monitor is running by setting the
* PMOND_FLAG occasionally in its pulse response. * PMOND_FLAG occasionally in its pulse response.
* The following if/else if clauses manage raising an alarm and degrading * The following if/else if clauses manage raising an alarm and degrading
* a host has stopped sending the PMOND_FLAG. */ * a host has stopped sending the PMOND_FLAG. */
if ( flags & PMOND_FLAG ) if ( flags & PMOND_FLAG )
@ -7707,8 +7738,8 @@ struct nodeLinkClass::node* nodeLinkClass::getPulseNode ( string & hostname , if
/* Find the node in the list of nodes being heartbeated and splice it out */ /* Find the node in the list of nodes being heartbeated and splice it out */
int nodeLinkClass::remPulse_by_index ( string hostname, int index, iface_enum iface, bool clear_b2b_misses_count, unsigned int flags ) int nodeLinkClass::remPulse_by_index ( string hostname, int index, iface_enum iface, bool clear_b2b_misses_count, unsigned int flags )
{ {
int rc = FAIL ; int rc = RETRY ;
if (( index > 0 ) && ( !(index > hosts))) if (!(index > hosts))
{ {
if ( hbs_rra[index] != NULL ) if ( hbs_rra[index] != NULL )
{ {
@ -7727,14 +7758,20 @@ int nodeLinkClass::remPulse_by_index ( string hostname, int index, iface_enum if
} }
else else
{ {
wlog_throttled ( node_ptr->unexpected_pulse_log_throttle, 200, "%s is not being monitored\n", hostname.c_str()); wlog_throttled ( node_ptr->unexpected_pulse_log_throttle, 200,
"%s is not being monitored\n",
hostname.c_str());
rc = PASS; rc = PASS;
} }
} }
else else
{ {
rc = remPulse_by_name ( hostname, iface, clear_b2b_misses_count, flags ); rc = remPulse_by_name ( hostname, iface, clear_b2b_misses_count, flags );
wlog_throttled ( node_ptr->lookup_mismatch_log_throttle, 200, "%s rri lookup mismatch (%s:%d) ; %s\n", hostname.c_str(), node_ptr->hostname.c_str(), index, rc ? "" : "removed by hostname" ); wlog_throttled ( node_ptr->lookup_mismatch_log_throttle, 200,
"%s rri lookup mismatch (%s:%d) ; %s\n",
hostname.c_str(),
node_ptr->hostname.c_str(),
index, rc ? "" : "removed by hostname" );
return (rc); return (rc);
} }
} }
@ -7984,13 +8021,6 @@ int nodeLinkClass::remPulse ( struct node * node_ptr, iface_enum iface, bool cle
* By index does not require a lookup whereas hostname does */ * By index does not require a lookup whereas hostname does */
int nodeLinkClass::remove_pulse ( string & hostname, iface_enum iface, int index, unsigned int flags ) int nodeLinkClass::remove_pulse ( string & hostname, iface_enum iface, int index, unsigned int flags )
{ {
/* TODO: consider removing this check */
if ( hostname == "localhost" )
{
/* localhost is not a supported hostname and indicates
* an unconfigured host response ; return the ignore response */
return(ENXIO);
}
if ( index ) if ( index )
{ {
int rc = remPulse_by_index ( hostname, index , iface, true , flags ); int rc = remPulse_by_index ( hostname, index , iface, true , flags );
@ -8001,8 +8031,11 @@ int nodeLinkClass::remove_pulse ( string & hostname, iface_enum iface, int index
default: mlog ("%s RRI Miss (rri:%d) (rc:%d)\n", hostname.c_str(), index, rc ); default: mlog ("%s RRI Miss (rri:%d) (rc:%d)\n", hostname.c_str(), index, rc );
} }
} }
else /* fast lookup not supported for hostnames longer than 31
* chars so in those cases don't do Not Offering RRI log */
if ( hostname.length() < MAX_CHARS_HOSTNAME_32 )
{ {
get_hbs_monitor_state ( hostname, iface ) ;
} }
return ( remPulse_by_name ( hostname , iface, true, flags )); return ( remPulse_by_name ( hostname , iface, true, flags ));
} }

3
mtce/src/common/nodeClass.h
View File

@ -1331,6 +1331,7 @@ public:
string my_hostname ; /**< */ string my_hostname ; /**< */
string my_local_ip ; /**< Primary IP address */ string my_local_ip ; /**< Primary IP address */
string my_float_ip ; /**< Secondary (floating) IP address */ string my_float_ip ; /**< Secondary (floating) IP address */
string my_clstr_ip ; /**< Cluster network IP address */
/********* New Public Constructs for IPMI Comamnd Handling ***********/ /********* New Public Constructs for IPMI Comamnd Handling ***********/
@ -1371,7 +1372,7 @@ public:
int set_clstr_hostaddr ( string & hostname, string & ip ); int set_clstr_hostaddr ( string & hostname, string & ip );
/** get hostname for any hostname */ /** get hostname for any hostname */
string get_hostname ( string & hostaddr ); string get_hostname ( string hostaddr );
/******************************/ /******************************/
/* NODE TYPE Member Functions */ /* NODE TYPE Member Functions */

251
mtce/src/heartbeat/hbsAgent.cpp
View File

@ -41,7 +41,7 @@ using namespace std;
#include "hbsBase.h" /* Heartbeat Base Header File */ #include "hbsBase.h" /* Heartbeat Base Header File */
#include "hbsAlarm.h" /* for ... hbsAlarm_clear_all */ #include "hbsAlarm.h" /* for ... hbsAlarm_clear_all */
#include "alarm.h" /* for ... alarm send message to mtcalarmd */ #include "alarm.h" /* for ... alarm send message to mtcalarmd */
#include "jsonUtil.h" /* for ... jsonUtil_get_key_val */ #include "jsonUtil.h" /* for ... jsonUtil_get_key_val */
/************************************************************** /**************************************************************
* Implementation Structure * Implementation Structure
@ -414,39 +414,6 @@ int daemon_configure ( void )
ilog("Mgmnt Port : %d (rx)", hbs_config.hbs_agent_mgmnt_port ); ilog("Mgmnt Port : %d (rx)", hbs_config.hbs_agent_mgmnt_port );
ilog("Mgmnt Port : %d (tx)\n", hbs_config.hbs_client_mgmnt_port ); ilog("Mgmnt Port : %d (tx)\n", hbs_config.hbs_client_mgmnt_port );
/* Fetch the cluster-host interface name.
* calls daemon_get_iface_master inside so the
* aggrigated name is returned if it exists */
get_clstr_iface (&hbs_config.clstr_iface );
if ( strlen(hbs_config.clstr_iface) )
{
if (!strcmp(hbs_config.clstr_iface, hbs_config.mgmnt_iface))
{
hbsInv.clstr_network_provisioned = false ;
}
else
{
hbsInv.clstr_network_provisioned = true ;
ilog ("Clstr Name : %s", hbs_config.clstr_iface );
ilog ("Clstr Port : %d (rx)", hbs_config.hbs_agent_clstr_port );
ilog ("Clstr Port : %d (tx)", hbs_config.hbs_client_clstr_port );
}
}
ilog("Command Port: %d (rx)\n", hbs_config.mtc_to_hbs_cmd_port );
ilog("Event Port : %d (tx)\n", hbs_config.hbs_to_mtc_event_port );
ilog("Alarm Port : %d (tx)\n", hbs_config.mtcalarm_req_port );
hbsInv.hbs_state_change = true ;
/* pull in the degrade only config option */
hbsInv.clstr_degrade_only = hbs_config.clstr_degrade_only ;
if ( hbsInv.hbs_degrade_threshold >= hbsInv.hbs_failure_threshold )
{
wlog ("Degrade threshold should be smaller than Failure threshold\n");
wlog ("Heartbeat 'degrade' state disabled ; see %s\n", MTCE_CONF_FILE);
}
for ( ;; ) for ( ;; )
{ {
get_ip_addresses ( hbsInv.my_hostname, hbsInv.my_local_ip , hbsInv.my_float_ip ); get_ip_addresses ( hbsInv.my_hostname, hbsInv.my_local_ip , hbsInv.my_float_ip );
@ -464,6 +431,39 @@ int daemon_configure ( void )
break ; break ;
} }
} }
/* Fetch the cluster-host interface name.
* calls daemon_get_iface_master inside so the
* aggrigated name is returned if it exists */
get_clstr_iface (&hbs_config.clstr_iface );
if ( strlen(hbs_config.clstr_iface) )
{
int rc = get_iface_address ( hbs_config.clstr_iface,
hbsInv.my_clstr_ip, false );
if ( rc )
{
elog ("get Clstr IP address failed '%s' (%d:%d:%m)\n",
hbs_config.clstr_iface, rc, errno );
}
else
{
ilog ("Clstr Addr : %s\n", hbsInv.my_clstr_ip.c_str());
}
if (!strcmp(hbs_config.clstr_iface, hbs_config.mgmnt_iface))
{
hbsInv.clstr_network_provisioned = false ;
}
else
{
hbsInv.clstr_network_provisioned = true ;
ilog ("Clstr Name : %s", hbs_config.clstr_iface );
ilog ("Clstr Port : %d (rx)", hbs_config.hbs_agent_clstr_port );
ilog ("Clstr Port : %d (tx)", hbs_config.hbs_client_clstr_port );
}
}
ilog("Command Port: %d (rx)\n", hbs_config.mtc_to_hbs_cmd_port );
ilog("Event Port : %d (tx)\n", hbs_config.hbs_to_mtc_event_port );
ilog("Alarm Port : %d (tx)\n", hbs_config.mtcalarm_req_port );
/* Set Controller Activity State */ /* Set Controller Activity State */
hbs_config.active = daemon_get_run_option ("active") ; hbs_config.active = daemon_get_run_option ("active") ;
@ -476,6 +476,19 @@ int daemon_configure ( void )
else else
hbsInv.set_activity_state ( false ); hbsInv.set_activity_state ( false );
/* Start assuming a change */
hbsInv.hbs_state_change = true ;
/* pull in the degrade only config option */
hbsInv.clstr_degrade_only = hbs_config.clstr_degrade_only ;
if ( hbsInv.hbs_degrade_threshold >= hbsInv.hbs_failure_threshold )
{
wlog ("Degrade threshold should be smaller than Failure threshold\n");
wlog ("Heartbeat 'degrade' state disabled ; see %s\n", MTCE_CONF_FILE);
}
return (PASS); return (PASS);
} }
@ -888,9 +901,6 @@ int hbs_pulse_request ( iface_enum iface,
int bytes = 0 ; int bytes = 0 ;
if ( hbs_sock.tx_sock[iface] ) if ( hbs_sock.tx_sock[iface] )
{ {
// int unused_networks = 0 ;
memset ( &hbs_sock.tx_mesg[iface].m[HBS_HEADER_SIZE], 0, MAX_CHARS_HOSTNAME );
/* Add message version - 0 -> 1 with the acction of cluster information */ /* Add message version - 0 -> 1 with the acction of cluster information */
hbs_sock.tx_mesg[iface].v = HBS_MESSAGE_VERSION ; hbs_sock.tx_mesg[iface].v = HBS_MESSAGE_VERSION ;
@ -903,14 +913,21 @@ int hbs_pulse_request ( iface_enum iface,
/* Add this controller's lookup_clue /* Add this controller's lookup_clue
* ... aka RRI (Resource Reference Index) */ * ... aka RRI (Resource Reference Index) */
/* Fast lookup clue supported for hostnames less than 32 bytes */
memset ( &hbs_sock.tx_mesg[iface].m[HBS_HEADER_SIZE], 0, MAX_CHARS_HOSTNAME_32 );
if (( lookup_clue ) && if (( lookup_clue ) &&
( hostname_clue.length() <= MAX_CHARS_HOSTNAME )) ( hostname_clue.length() < MAX_CHARS_HOSTNAME_32 ))
{ {
hbs_sock.tx_mesg[iface].c = lookup_clue ; hbs_sock.tx_mesg[iface].c = lookup_clue ;
memcpy ( &hbs_sock.tx_mesg[iface].m[HBS_HEADER_SIZE], memcpy ( &hbs_sock.tx_mesg[iface].m[HBS_HEADER_SIZE],
hostname_clue.data(), hostname_clue.data(),
hostname_clue.length()); hostname_clue.length());
} }
else
{
hbs_sock.tx_mesg[iface].c = 0;
}
/* Append the cluster info to the pulse request */ /* Append the cluster info to the pulse request */
hbs_cluster_append(hbs_sock.tx_mesg[iface]) ; hbs_cluster_append(hbs_sock.tx_mesg[iface]) ;
@ -973,19 +990,6 @@ hbs_pulse_request_out:
return (PASS); return (PASS);
} }
string get_hostname_from_pulse ( char * msg_ptr )
{
char temp [MAX_HOST_NAME_SIZE];
string hostname ;
char * str_ptr = strstr ( msg_ptr, ":" );
memset ( temp, 0 , MAX_HOST_NAME_SIZE );
sscanf ( ++str_ptr, "%31s", &temp[0] );
hostname = temp ;
return (hostname);
}
int _pulse_receive ( iface_enum iface , unsigned int seq_num ) int _pulse_receive ( iface_enum iface , unsigned int seq_num )
{ {
int bytes = 0 ; int bytes = 0 ;
@ -1022,9 +1026,9 @@ int _pulse_receive ( iface_enum iface , unsigned int seq_num )
// (hbs_sock.rx_mesg[iface].f & CTRLX_MASK ) >> CTRLX_BIT); // (hbs_sock.rx_mesg[iface].f & CTRLX_MASK ) >> CTRLX_BIT);
continue ; continue ;
} }
mlog ("%s Pulse Rsp: (%d) %s:%d: s:%d f:%x [%-27s] RRI:%d\n", mlog ("%s Pulse Rsp: (%d) from:%s:%d: s:%d flags:%x [%-27s] RRI:%d\n",
get_iface_name_str(iface), bytes, get_iface_name_str(iface), bytes,
hbs_sock.rx_sock[iface]->get_dst_addr()->toString(), hbs_sock.rx_sock[iface]->get_src_str(),
hbs_sock.rx_sock[iface]->get_dst_addr()->getPort(), hbs_sock.rx_sock[iface]->get_dst_addr()->getPort(),
hbs_sock.rx_mesg[iface].s, hbs_sock.rx_mesg[iface].s,
hbs_sock.rx_mesg[iface].f, hbs_sock.rx_mesg[iface].f,
@ -1035,7 +1039,7 @@ int _pulse_receive ( iface_enum iface , unsigned int seq_num )
if ( strstr ( hbs_sock.rx_mesg[iface].m, rsp_msg_header) ) if ( strstr ( hbs_sock.rx_mesg[iface].m, rsp_msg_header) )
{ {
int rc = RETRY ; int rc = RETRY ;
string hostname = get_hostname_from_pulse (&hbs_sock.rx_mesg[iface].m[0]); string hostname = hbsInv.get_hostname (hbs_sock.rx_sock[iface]->get_src_str());
#ifdef WANT_FIT_TESTING #ifdef WANT_FIT_TESTING
if ( hbs_config.testmode == 1 ) if ( hbs_config.testmode == 1 )
@ -1169,11 +1173,6 @@ int _pulse_receive ( iface_enum iface , unsigned int seq_num )
int send_event ( string & hostname, unsigned int event_cmd, iface_enum iface ) int send_event ( string & hostname, unsigned int event_cmd, iface_enum iface )
{ {
int bytes ;
int bytes_to_send ;
int rc = PASS ;
int retries = 0 ;
if ((hbs_sock.hbs_event_tx_sock == NULL ) || if ((hbs_sock.hbs_event_tx_sock == NULL ) ||
(hbs_sock.hbs_event_tx_sock->sock_ok() == false )) (hbs_sock.hbs_event_tx_sock->sock_ok() == false ))
{ {
@ -1192,23 +1191,10 @@ int send_event ( string & hostname, unsigned int event_cmd, iface_enum iface )
hbs_cluster_log ( hbsInv.my_hostname, "event", true ); hbs_cluster_log ( hbsInv.my_hostname, "event", true );
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_loss_header()); snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_loss_header());
} }
else if ( event_cmd == MTC_EVENT_LOOPBACK ) else if (( event_cmd == MTC_EVENT_HEARTBEAT_MINOR_SET ) ||
{ ( event_cmd == MTC_EVENT_HEARTBEAT_MINOR_CLR ) ||
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header()); ( event_cmd == MTC_EVENT_HEARTBEAT_DEGRADE_SET ) ||
} ( event_cmd == MTC_EVENT_HEARTBEAT_DEGRADE_CLR ))
else if ( event_cmd == MTC_EVENT_HEARTBEAT_MINOR_SET )
{
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header());
}
else if ( event_cmd == MTC_EVENT_HEARTBEAT_MINOR_CLR )
{
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header());
}
else if ( event_cmd == MTC_EVENT_HEARTBEAT_DEGRADE_SET )
{
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header());
}
else if ( event_cmd == MTC_EVENT_HEARTBEAT_DEGRADE_CLR )
{ {
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header()); snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_heartbeat_event_header());
} }
@ -1228,38 +1214,34 @@ int send_event ( string & hostname, unsigned int event_cmd, iface_enum iface )
return ( FAIL_BAD_CASE ); return ( FAIL_BAD_CASE );
} }
/* Put the hostname in the buffer - as well */ snprintf ( &event.hdr[MSG_HEADER_SIZE] , MAX_CHARS_HOSTNAME_32, "%s", hostname.data());
snprintf ( &event.buf[0] , MAX_CHARS_HOSTNAME, "%s", hostname.data());
/* TODO: obsolete this method in the future as it limits the host name lenth to 32 */
snprintf ( &event.hdr[MSG_HEADER_SIZE] , MAX_CHARS_HOSTNAME, "%s", hostname.data());
event.cmd = event_cmd ; event.cmd = event_cmd ;
event.num = 1 ; event.num = 1 ;
event.parm[0] = iface ; event.parm[0] = iface ;
/* Support for 64 byte hostnames */
event.ver = MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF ;
/* Json string starts at the beginning of the buffer */
event.res = 0 ;
string buf_info = "{\"hostname\":\"" ;
buf_info.append(hostname);
buf_info.append("\",\"service\":\"");
buf_info.append(MTC_SERVICE_HBSAGENT_NAME);
buf_info.append("\"}");
/* copy the string into the buffer and add one to the length to
* accomodate for the null terminator snprintf automatically adds */
snprintf ( &event.buf[event.res], buf_info.length()+1, "%s", buf_info.data());
print_mtc_message ( hostname, MTC_CMD_TX, event, get_iface_name_str(iface) , false ); print_mtc_message ( hostname, MTC_CMD_TX, event, get_iface_name_str(iface) , false );
if ( hbs_sock.hbs_event_tx_sock->write((char*)&event, sizeof(mtc_message_type)) <= 0 )
/* remove the buffer as it is not needed for this message */
bytes_to_send = ((sizeof(mtc_message_type))-(BUF_SIZE-hostname.length())) ;
do
{ {
bytes = hbs_sock.hbs_event_tx_sock->write((char*)&event,bytes_to_send); elog ("%s failed to send event to maintenance (%d:%m)", hostname.c_str(), errno );
if ( bytes <= 0 ) return ( FAIL_TO_TRANSMIT ) ;
{ }
rc = FAIL_TO_TRANSMIT ; return PASS ;
if ( retries++ > 3 )
{
elog ("Cannot communicate with maintenance\n");
return (RETRY);
}
}
else
rc = PASS ;
} while ( bytes <= 0 ) ;
return rc ;
} }
/* The main heartbeat service loop */ /* The main heartbeat service loop */
@ -1830,13 +1812,47 @@ void daemon_service_run ( void )
bytes = hbs_sock.mtc_to_hbs_sock->read((char*)&msg,sizeof(mtc_message_type)); bytes = hbs_sock.mtc_to_hbs_sock->read((char*)&msg,sizeof(mtc_message_type));
if ( bytes > 0 ) if ( bytes > 0 )
{ {
mlog ("Received Maintenance Command (%i)\n", bytes );
mlog ("%s - cmd:0x%x\n", &msg.hdr[0], msg.cmd );
if ( !strncmp ( get_hbs_cmd_req_header(), &msg.hdr[0], MSG_HEADER_SIZE )) if ( !strncmp ( get_hbs_cmd_req_header(), &msg.hdr[0], MSG_HEADER_SIZE ))
{ {
string hostname = &msg.hdr[MSG_HEADER_SIZE] ; string hostname ;
if ( msg.cmd == MTC_CMD_ACTIVE_CTRL ) node_inv_type inv ;
node_inv_init(inv);
/* 64 byte hostname support adds a json string to
* the message buffer containing the hostname as a
* key/value pair. */
if (( msg.ver >= MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF ) &&
( msg.buf[msg.res] == '{' ))
{
if ( jsonUtil_get_key_val(&msg.buf[msg.res],
MTC_JSON_INV_NAME, hostname) == PASS )
{
inv.name = hostname ;
if (( msg.cmd == MTC_CMD_ADD_HOST ) ||
( msg.cmd == MTC_CMD_MOD_HOST ))
{
jsonUtil_get_key_val(&msg.buf[msg.res], MTC_JSON_INV_HOSTIP, inv.ip);
if ( hbsInv.clstr_network_provisioned == true )
{
jsonUtil_get_key_val(&msg.buf[msg.res], MTC_JSON_INV_CLSTRIP, inv.clstr_ip);
}
}
}
}
else if ( msg.hdr[MSG_HEADER_SIZE] != '\0' )
{
/* get hostname by legacy method,
* ... from the header */
hostname = &msg.hdr[MSG_HEADER_SIZE] ;
}
if ( hostname.empty() )
{
/* no hostname ; no action to take */
wlog ("unable to get hostname from %s command",
get_mtcNodeCommand_str(msg.cmd));
}
else if ( msg.cmd == MTC_CMD_ACTIVE_CTRL )
{ {
bool logit = false ; bool logit = false ;
if ( hostname == hbsInv.my_hostname ) if ( hostname == hbsInv.my_hostname )
@ -1876,13 +1892,12 @@ void daemon_service_run ( void )
} }
else if ( msg.cmd == MTC_CMD_ADD_HOST ) else if ( msg.cmd == MTC_CMD_ADD_HOST )
{ {
node_inv_type inv ;
node_inv_init(inv);
inv.name = hostname ;
inv.nodetype = msg.parm[0]; inv.nodetype = msg.parm[0];
hbsInv.add_heartbeat_host ( inv ) ; hbsInv.add_heartbeat_host ( inv ) ;
hostname_inventory.push_back ( hostname ); hostname_inventory.push_back ( inv.name );
ilog ("%s added to heartbeat service (%d)\n", hostname.c_str(), msg.parm[0] ); ilog ("%s added to heartbeat service (%d)\n",
inv.name.c_str(),
inv.nodetype);
/* clear any outstanding alarms on the ADD */ /* clear any outstanding alarms on the ADD */
if (( hbsInv.hbs_failure_action != HBS_FAILURE_ACTION__NONE ) && if (( hbsInv.hbs_failure_action != HBS_FAILURE_ACTION__NONE ) &&
@ -1892,6 +1907,20 @@ void daemon_service_run ( void )
hbsInv.clstr_network_provisioned ); hbsInv.clstr_network_provisioned );
} }
} }
else if ( msg.cmd == MTC_CMD_MOD_HOST )
{
inv.nodetype = msg.parm[0];
hbsInv.add_heartbeat_host ( inv ) ;
ilog ("%s modified heartbeat info [%d]\n",
inv.name.c_str(),
inv.nodetype );
/* clear any outstanding alarms on the ADD */
if ( hbsInv.hbs_failure_action != HBS_FAILURE_ACTION__NONE )
{
hbsAlarm_clear_all ( hostname, hbsInv.clstr_network_provisioned );
}
}
else if ( msg.cmd == MTC_CMD_DEL_HOST ) else if ( msg.cmd == MTC_CMD_DEL_HOST )
{ {
hbsInv.mon_host ( hostname, false, false ); hbsInv.mon_host ( hostname, false, false );

2
mtce/src/heartbeat/hbsBase.h
View File

@ -61,7 +61,7 @@ const char req_msg_header [HBS_HEADER_SIZE+1] = {"cgts pulse req:"};
/** Heartbeat pulse response message header content */ /** Heartbeat pulse response message header content */
const char rsp_msg_header [HBS_HEADER_SIZE+1] = {"cgts pulse rsp:"}; const char rsp_msg_header [HBS_HEADER_SIZE+1] = {"cgts pulse rsp:"};
#define HBS_MAX_MSG (HBS_HEADER_SIZE+MAX_CHARS_HOSTNAME) #define HBS_MAX_MSG (HBS_HEADER_SIZE+MAX_CHARS_HOSTNAME_32)
#define HBS_MESSAGE_VERSION (1) // 0 -> 1 with intro of cluster info #define HBS_MESSAGE_VERSION (1) // 0 -> 1 with intro of cluster info

38
mtce/src/heartbeat/hbsClient.cpp
View File

@ -875,6 +875,18 @@ int _service_pulse_request ( iface_enum iface , unsigned int flags )
} }
} }
/* Manage the Resource Reference Index (RRI) "lookup clue"
* Only supported for hostnames -lt 32 bytes */
if (( strnlen(&my_hostname[0], MAX_CHARS_HOSTNAME) < MAX_CHARS_HOSTNAME_32) &&
(!strncmp(&hbs_sock.rx_mesg[iface].m[HBS_HEADER_SIZE], &my_hostname[0], MAX_CHARS_HOSTNAME_32)))
{
if( rri[controller] != hbs_sock.rx_mesg[iface].c )
{
rri[controller] = hbs_sock.rx_mesg[iface].c ;
ilog ("Caching New RRI: %d (from controller-%d)\n", rri[controller], controller );
}
}
/* Log the received cluster info /* Log the received cluster info
* ... if the message version shows that it is supported */ * ... if the message version shows that it is supported */
if ( hbs_sock.rx_mesg[iface].v ) if ( hbs_sock.rx_mesg[iface].v )
@ -1070,7 +1082,6 @@ int hbs_send_event ( unsigned int event )
mtc_message_type msg ; mtc_message_type msg ;
int rc = FAIL_BAD_PARM ; int rc = FAIL_BAD_PARM ;
int bytes = 0 ;
memset (&msg, 0 , sizeof(mtc_message_type)); memset (&msg, 0 , sizeof(mtc_message_type));
@ -1097,22 +1108,31 @@ int hbs_send_event ( unsigned int event )
/* build the message */ /* build the message */
snprintf ( &msg.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header()); snprintf ( &msg.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header());
snprintf ( &msg.hdr[MSG_HEADER_SIZE], MAX_CHARS_HOSTNAME, "%s", &my_hostname[0]);
#define MAX_PROC_NAME_SIZE (64)
snprintf ( &msg.buf[0], MAX_PROC_NAME_SIZE, "%s", program_invocation_short_name);
size_t len = strlen(program_invocation_short_name);
bytes = ((sizeof(mtc_message_type))-(BUF_SIZE-len));
msg.cmd = event ; msg.cmd = event ;
msg.ver = MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF ;
string event_info = "{\"" ;
event_info.append(MTC_JSON_INV_NAME);
event_info.append("\":\"");
event_info.append(my_hostname);
event_info.append("\",\"");
event_info.append(MTC_JSON_SERVICE);
event_info.append("\":\"");
event_info.append(MTC_SERVICE_HBSCLIENT_NAME );
event_info.append( "\"}");
size_t len = event_info.length()+1 ;
snprintf ( &msg.buf[0], len, "%s", event_info.data());
int bytes = ((sizeof(mtc_message_type))-(BUF_SIZE-len));
if (( hbs_sock.hbs_ready_tx_sock ) && if (( hbs_sock.hbs_ready_tx_sock ) &&
( hbs_sock.hbs_ready_tx_sock->sock_ok() == true )) ( hbs_sock.hbs_ready_tx_sock->sock_ok() == true ))
{ {
mlog ("Ready message\n"); mlog ("%s sending ready event\n", my_hostname );
if ((rc = hbs_sock.hbs_ready_tx_sock->write((char*)&msg.hdr[0], bytes))!= bytes ) if ((rc = hbs_sock.hbs_ready_tx_sock->write((char*)&msg.hdr[0], bytes))!= bytes )
{ {
elog ("Ready message send failed (%d) (%d:%s)\n", rc, errno, strerror(errno) ); elog ("... ready event send failed (%d) (%d:%s)\n", rc, errno, strerror(errno) );
rc = FAIL_SOCKET_SENDTO ; rc = FAIL_SOCKET_SENDTO ;
} }
else else

2
mtce/src/hwmon/hwmonInit.cpp
View File

@ -357,7 +357,7 @@ void daemon_service_run ( void )
ilog ("Transmitting: Monitor READY Event\n" ); ilog ("Transmitting: Monitor READY Event\n" );
do do
{ {
rc = hwmon_send_event ( hwmon_ctrl.my_hostname, MTC_EVENT_MONITOR_READY, "hwmond" ); rc = hwmon_send_event ( hwmon_ctrl.my_hostname, MTC_EVENT_MONITOR_READY, "" );
if ( rc == RETRY ) if ( rc == RETRY )
{ {
mtcWait_secs ( 2 ); mtcWait_secs ( 2 );

108
mtce/src/hwmon/hwmonMsg.cpp
View File

@ -131,9 +131,7 @@ int mtclogd_tx_port_init ( void )
int hwmon_send_event ( string hostname, unsigned int event_code , const char * sensor_ptr ) int hwmon_send_event ( string hostname, unsigned int event_code , const char * sensor_ptr )
{ {
mtc_message_type event ; mtc_message_type event ;
int rc = PASS ;
int rc = FAIL ;
int bytes = 0 ;
memset (&event, 0 , sizeof(mtc_message_type)); memset (&event, 0 , sizeof(mtc_message_type));
@ -149,59 +147,55 @@ int hwmon_send_event ( string hostname, unsigned int event_code , const char * s
( event_code == MTC_DEGRADE_RAISE ) || ( event_code == MTC_DEGRADE_RAISE ) ||
( event_code == MTC_DEGRADE_CLEAR )) ( event_code == MTC_DEGRADE_CLEAR ))
{ {
mlog ("%s sending '%s' event to mtcAgent for '%s'\n", string event_info = "" ;
hostname.c_str(),
mlog ("%s sending '%s' event to mtcAgent for '%s'\n",
hostname.c_str(),
get_event_str(event_code).c_str(), get_event_str(event_code).c_str(),
sensor_ptr ); sensor_ptr );
snprintf ( &event.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header()); snprintf ( &event.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header());
snprintf ( &event.hdr[MSG_HEADER_SIZE] , MAX_CHARS_HOSTNAME , "%s", hostname.data()); /* Limit the size of the hostname in the header to 32 bytes
* - legacy support */
snprintf ( &event.hdr[MSG_HEADER_SIZE] , MAX_CHARS_HOSTNAME_32, "%s", hostname.data());
/* Add support for up to 64 byte hostnames as a
* json string in the buffer. */
event.ver = MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF ;
event_info.append( "{\"service\":\"hwmond\",\"hostname\":\"" ) ;
event_info.append( hostname );
if ( sensor_ptr ) if ( sensor_ptr )
{ {
size_t len = strnlen ( sensor_ptr, MAX_SENSOR_NAME_LEN ); event_info.append( "\",\"sensor\":\"" ) ;
event_info.append( sensor_ptr );
/* We don't use the buffer for hwmon events to remove it from the size */ }
bytes = ((sizeof(mtc_message_type))-(BUF_SIZE-len)); event_info.append( "\"}");
snprintf ( &event.buf[event.res] , event_info.length()+1, "%s", event_info.data());
snprintf ( &event.buf[0], MAX_SENSOR_NAME_LEN, "%s", sensor_ptr ); /* Update the event code */
event.cmd = event_code ;
/* Send the event */
rc = hwmon_sock.event_sock->write((char*)&event.hdr[0],sizeof(mtc_message_type));
if ( rc )
{
rc = PASS ;
}
else
{
elog ("event send to %s:%d failed (%d:%d:%m)",
hwmon_sock.event_sock->get_dst_str(),
hwmon_sock.event_sock->get_dst_addr()->getPort(), rc, errno);
rc = FAIL_SOCKET_SENDTO ;
} }
} }
else if ( event_code == MTC_EVENT_LOOPBACK )
{
snprintf ( &event.hdr[MSG_HEADER_SIZE] , MAX_CHARS_HOSTNAME , "%s", hostname.data());
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_loopback_header());
/* We don't use the buffer for hwmon events to remove it from the size */
bytes = ((sizeof(mtc_message_type))-(BUF_SIZE));
}
else else
{ {
elog ("Unsupported process monitor event (%d)\n", event_code ); elog ("Unsupported hardware monitor event (%d)\n", event_code );
return ( FAIL_BAD_PARM ); rc = FAIL_BAD_PARM ;
}
/* Update the event code */
event.cmd = event_code ;
/* Send the event */
if ((rc = hwmon_sock.event_sock->write((char*)&event.hdr[0],bytes)) != bytes )
{
elog ("Message send failed. (%d)\n", rc);
elog ("Message: %d bytes to <%s:%d>\n", bytes,
hwmon_sock.event_sock->get_dst_str(),
hwmon_sock.event_sock->get_dst_addr()->getPort());
rc = FAIL_SOCKET_SENDTO ;
}
else
{
mlog ("Sending '%s' Event with %d bytes to %s:%d\n",
get_event_str (event.cmd).c_str(), bytes,
hwmon_sock.event_sock->get_dst_str(),
hwmon_sock.event_sock->get_dst_addr()->getPort());
print_mtc_message (&event);
rc = PASS ;
} }
print_mtc_message ( hostname, MTC_CMD_TX, event, get_iface_name_str(MGMNT_INTERFACE), rc );
return rc ; return rc ;
} }
@ -213,7 +207,7 @@ int hwmon_service_inbox ( void )
int rc = PASS ; int rc = PASS ;
/* clean the rx/tx buffer */ /* clean the rx/tx buffer */
memset ((void*)&msg,0,sizeof(mtc_message_type)); memset ((void*)&msg,0,sizeof(mtc_message_type));
bytes = hwmon_sock.cmd_sock->read((char*)&msg.hdr[0], sizeof(mtc_message_type)); bytes = hwmon_sock.cmd_sock->read((char*)&msg.hdr[0], sizeof(mtc_message_type));
if( bytes <= 0 ) if( bytes <= 0 )
@ -238,8 +232,6 @@ int hwmon_service_inbox ( void )
hwmon_sock.cmd_sock->get_src_str(), hwmon_sock.cmd_sock->get_src_str(),
hwmon_sock.cmd_sock->get_dst_addr()->getPort()); hwmon_sock.cmd_sock->get_dst_addr()->getPort());
print_mtc_message ( &msg );
if ( !strnlen ( &msg.hdr[MSG_HEADER_SIZE], MAX_CHARS_HOSTNAME )) if ( !strnlen ( &msg.hdr[MSG_HEADER_SIZE], MAX_CHARS_HOSTNAME ))
{ {
wlog ("Mtce message (%x) did not specify target hostname\n", msg.cmd ); wlog ("Mtce message (%x) did not specify target hostname\n", msg.cmd );
@ -254,6 +246,7 @@ int hwmon_service_inbox ( void )
wlog ("%s failed to parse host info\n", inv.name.c_str()); wlog ("%s failed to parse host info\n", inv.name.c_str());
return (FAIL_KEY_VALUE_PARSE); return (FAIL_KEY_VALUE_PARSE);
} }
print_mtc_message ( inv.name, MTC_CMD_RX, msg, get_iface_name_str(MGMNT_IFACE) , false);
rc = PASS; rc = PASS;
if ( msg.cmd == MTC_CMD_ADD_HOST ) if ( msg.cmd == MTC_CMD_ADD_HOST )
@ -269,7 +262,6 @@ int hwmon_service_inbox ( void )
{ {
mlog ("%s add host message\n", inv.name.c_str()); mlog ("%s add host message\n", inv.name.c_str());
} }
} }
else if ( msg.cmd == MTC_CMD_DEL_HOST ) else if ( msg.cmd == MTC_CMD_DEL_HOST )
{ {
@ -306,17 +298,13 @@ int hwmon_service_inbox ( void )
{ {
mlog ("%s query host message - NOT IMPLEMENTED YET !!!\n", inv.name.c_str()); mlog ("%s query host message - NOT IMPLEMENTED YET !!!\n", inv.name.c_str());
} }
else if ( msg.cmd == MTC_CMD_LOOPBACK )
{
mlog ("Loopback command received\n");
}
else else
{ {
rc = FAIL_BAD_PARM ; rc = FAIL_BAD_PARM ;
elog ( "Unsupported maintenance command (%d)\n", msg.cmd ); elog ( "Unsupported maintenance command (%d)\n", msg.cmd );
} }
} }
else else
{ {
elog ("Unsupported Message\n"); elog ("Unsupported Message\n");
print_mtc_message ( &msg ) ; print_mtc_message ( &msg ) ;
@ -324,15 +312,14 @@ int hwmon_service_inbox ( void )
} }
#ifdef WANT_COMMAND_RESPONSE #ifdef WANT_COMMAND_RESPONSE
/* TODO: Test and enable reply message */ /* TODO: Test and enable reply message */
// snprintf ( &msg.hdr[0], MSG_HEADER_SIZE, "%s", get_cmd_rsp_msg_header()); // snprintf ( &msg.hdr[0], MSG_HEADER_SIZE, "%s", get_cmd_rsp_msg_header());
if ( rc == PASS ) if ( rc == PASS )
{ {
bytes = sizeof(mtc_message_type)-BUF_SIZE; bytes = sizeof(mtc_message_type)-BUF_SIZE;
rc = sendto( hwmon_sock.mtc_client_tx_sock, rc = sendto( hwmon_sock.mtc_client_tx_sock,
(char*)&msg.hdr[0], bytes , 0, (char*)&msg.hdr[0], bytes , 0,
(struct sockaddr *) &hwmon_sock.agent_addr, (struct sockaddr *) &hwmon_sock.agent_addr,
sizeof(hwmon_sock.agent_addr)); sizeof(hwmon_sock.agent_addr));
if (rc != bytes ) if (rc != bytes )
{ {
@ -345,9 +332,8 @@ int hwmon_service_inbox ( void )
{ {
mlog ("Response: <%s> to %s:%d\n", &msg.hdr[0], mlog ("Response: <%s> to %s:%d\n", &msg.hdr[0],
inet_ntoa(hwmon_sock.client_addr.sin_addr), inet_ntoa(hwmon_sock.client_addr.sin_addr),
ntohs(hwmon_sock.agent_addr.sin_port)); ntohs(hwmon_sock.agent_addr.sin_port));
} }
fflush(stdout);
} }
#endif #endif
return (rc); return (rc);

35
mtce/src/maintenance/mtcCompMsg.cpp
View File

@ -61,10 +61,11 @@ int mtc_service_command ( mtc_socket_type * sock_ptr, int interface )
int bytes = 0 ; int bytes = 0 ;
mtc_message_type msg ; mtc_message_type msg ;
int rc = FAIL ; int rc = FAIL ;
ctrl_type * ctrl_ptr = get_ctrl_ptr() ;
if ( interface == CLSTR_INTERFACE ) if ( interface == CLSTR_INTERFACE )
{ {
if ( ! get_ctrl_ptr()->clstr_iface_provisioned ) if ( ! ctrl_ptr->clstr_iface_provisioned )
{ {
wlog ("cannot receive from unprovisioned %s interface\n", wlog ("cannot receive from unprovisioned %s interface\n",
get_iface_name_str(interface) ); get_iface_name_str(interface) );
@ -74,13 +75,14 @@ int mtc_service_command ( mtc_socket_type * sock_ptr, int interface )
/* clean the rx/tx buffer */ /* clean the rx/tx buffer */
memset ((void*)&msg,0,sizeof(mtc_message_type)); memset ((void*)&msg,0,sizeof(mtc_message_type));
string hostaddr = "" ;
if ( interface == MGMNT_INTERFACE ) if ( interface == MGMNT_INTERFACE )
{ {
if (( sock_ptr->mtc_client_rx_socket ) && if (( sock_ptr->mtc_client_rx_socket ) &&
( sock_ptr->mtc_client_rx_socket->sock_ok() == true )) ( sock_ptr->mtc_client_rx_socket->sock_ok() == true ))
{ {
bytes = sock_ptr->mtc_client_rx_socket->read((char*)&msg.hdr[0], sizeof(mtc_message_type)); rc = sock_ptr->mtc_client_rx_socket->read((char*)&msg.hdr[0], sizeof(mtc_message_type));
hostaddr = sock_ptr->mtc_client_rx_socket->get_src_str();
} }
else else
{ {
@ -93,7 +95,8 @@ int mtc_service_command ( mtc_socket_type * sock_ptr, int interface )
if (( sock_ptr->mtc_client_clstr_rx_socket ) && if (( sock_ptr->mtc_client_clstr_rx_socket ) &&
( sock_ptr->mtc_client_clstr_rx_socket->sock_ok() == true )) ( sock_ptr->mtc_client_clstr_rx_socket->sock_ok() == true ))
{ {
bytes = sock_ptr->mtc_client_clstr_rx_socket->read((char*)&msg.hdr[0], sizeof(mtc_message_type)); rc = sock_ptr->mtc_client_clstr_rx_socket->read((char*)&msg.hdr[0], sizeof(mtc_message_type));
hostaddr = sock_ptr->mtc_client_clstr_rx_socket->get_src_str();
} }
else else
{ {
@ -102,7 +105,7 @@ int mtc_service_command ( mtc_socket_type * sock_ptr, int interface )
} }
} }
if( bytes <= 0 ) if( rc <= 0 )
{ {
if ( ( errno == EINTR ) || ( errno == EAGAIN )) if ( ( errno == EINTR ) || ( errno == EAGAIN ))
{ {
@ -113,24 +116,34 @@ int mtc_service_command ( mtc_socket_type * sock_ptr, int interface )
return (FAIL_TO_RECEIVE); return (FAIL_TO_RECEIVE);
} }
} }
rc = PASS ;
print_mtc_message ( get_hostname(), MTC_CMD_RX, msg, get_iface_name_str(interface), false ); bool self = false ;
if (( hostaddr == ctrl_ptr->address ) ||
( hostaddr == ctrl_ptr->address_clstr ))
{
self = true ;
}
/* Message version greater than zero have the hosts management /* Message version greater than zero have the hosts management
* mac address appended to the header string */ * mac address appended to the header string */
if ( msg.ver >= MTC_CMD_FEATURE_VER__MACADDR_IN_CMD ) if (( !self ) && ( msg.ver >= MTC_CMD_FEATURE_VER__MACADDR_IN_CMD ))
{ {
/* the minus 1 is to back up from the null char that is accounted for in the hearder size */ /* the minus 1 is to back up from the null char that is accounted for in the hearder size */
if ( strncmp ( &msg.hdr[MSG_HEADER_SIZE-1], get_ctrl_ptr()->macaddr.data(), MSG_HEADER_SIZE )) if ( strncmp ( &msg.hdr[MSG_HEADER_SIZE-1], ctrl_ptr->macaddr.data(), MSG_HEADER_SIZE ))
{ {
wlog ("%s command not for this host (exp:%s det:%s) ; ignoring ...\n", wlog ("%s command not for this host (exp:%s det:%s) ; ignoring ...\n",
get_mtcNodeCommand_str(msg.cmd), get_mtcNodeCommand_str(msg.cmd),
get_ctrl_ptr()->macaddr.c_str(), ctrl_ptr->macaddr.c_str(),
&msg.hdr[MSG_HEADER_SIZE-1]); &msg.hdr[MSG_HEADER_SIZE-1]);
print_mtc_message ( get_hostname(), MTC_CMD_RX, msg, get_iface_name_str(interface), true ); rc = FAIL_INVALID_DATA ;
return (FAIL_INVALID_DATA);
} }
} }
print_mtc_message ( hostaddr, MTC_CMD_RX, msg, get_iface_name_str(interface), rc );
if ( rc )
return rc;
/* Check for response messages */ /* Check for response messages */
if ( strstr ( &msg.hdr[0], get_cmd_req_msg_header() ) ) if ( strstr ( &msg.hdr[0], get_cmd_req_msg_header() ) )
{ {

853
mtce/src/maintenance/mtcCtrlMsg.cpp
View File

File diff suppressed because it is too large Load Diff

4
mtce/src/maintenance/mtcHttpSvr.cpp
View File

@ -416,8 +416,7 @@ string mtcHttpSvr_inv_req ( char * request_ptr,
{ {
node_inv_type inv ; node_inv_type inv ;
node_inv_init (inv); node_inv_init (inv);
dlog ("%s %s : '%s'\n", obj_ptr->my_hostname.c_str(), key.c_str(), value.c_str()) ;
ilog ("%s %s : '%s'\n", obj_ptr->my_hostname.c_str(), key.c_str(), value.c_str()) ;
rc = jsonUtil_load_host ( request_ptr, inv ); rc = jsonUtil_load_host ( request_ptr, inv );
if ( rc == PASS ) if ( rc == PASS )
@ -449,6 +448,7 @@ string mtcHttpSvr_inv_req ( char * request_ptr,
*/ */
if ( rc == RETRY ) if ( rc == RETRY )
{ {
ilog ("%s Modify Operation\n", inv.name.c_str());
rc = obj_ptr->mod_host ( inv ); rc = obj_ptr->mod_host ( inv );
} }

2
mtce/src/maintenance/mtcNodeComp.cpp
View File

@ -289,7 +289,7 @@ void setup_mgmnt_rx_socket ( void )
ilog("Mgmnt iface : %s\n", ctrl.mgmnt_iface.c_str() ); ilog("Mgmnt iface : %s\n", ctrl.mgmnt_iface.c_str() );
get_iface_macaddr ( ctrl.mgmnt_iface.data(), ctrl.macaddr ); get_iface_macaddr ( ctrl.mgmnt_iface.data(), ctrl.macaddr );
get_iface_address ( ctrl.mgmnt_iface.data(), ctrl.address , true ); get_iface_address ( ctrl.mgmnt_iface.data(), ctrl.address , true );
get_hostname ( &ctrl.hostname[0], MAX_HOST_NAME_SIZE ); get_hostname ( &ctrl.hostname[0], MAX_HOST_NAME_SIZE );
_close_mgmnt_rx_socket (); _close_mgmnt_rx_socket ();
mtc_sock.mtc_client_rx_socket = new msgClassRx(ctrl.address.c_str(),mtc_sock.mtc_cmd_port, IPPROTO_UDP, ctrl.mgmnt_iface.data(), false ); mtc_sock.mtc_client_rx_socket = new msgClassRx(ctrl.address.c_str(),mtc_sock.mtc_cmd_port, IPPROTO_UDP, ctrl.mgmnt_iface.data(), false );

4
mtce/src/maintenance/mtcNodeCtrl.cpp
View File

@ -649,15 +649,13 @@ int daemon_configure ( void )
ilog("Inv Port : %d (tx)\n", mtc_config.sysinv_api_port ); ilog("Inv Port : %d (tx)\n", mtc_config.sysinv_api_port );
ilog("Inv Address : %s (tx)\n", mtc_config.sysinv_api_bind_ip ); ilog("Inv Address : %s (tx)\n", mtc_config.sysinv_api_bind_ip );
ilog("Inv Event : %d (rx)\n", mtc_config.inv_event_port ); ilog("Inv Event : %d (rx)\n", mtc_config.inv_event_port );
ilog("Keystone Port: %d (rx)\n", mtc_config.keystone_port ); ilog("Keystone Prt: %d (rx)\n", mtc_config.keystone_port );
ilog("Mtce Logger : %d (tx)\n", mtc_config.daemon_log_port ); ilog("Mtce Logger : %d (tx)\n", mtc_config.daemon_log_port );
ilog("nfv-vim-api : %d (port)\n", mtc_config.vim_cmd_port ); ilog("nfv-vim-api : %d (port)\n", mtc_config.vim_cmd_port );
ilog("hbsAgent : %d (port)\n", mtc_config.mtc_to_hbs_cmd_port ); ilog("hbsAgent : %d (port)\n", mtc_config.mtc_to_hbs_cmd_port );
ilog("guestAgent : %d (port)\n", mtc_config.mtc_to_guest_cmd_port ); ilog("guestAgent : %d (port)\n", mtc_config.mtc_to_guest_cmd_port );
ilog("hwmond : %d (port)\n", mtc_config.hwmon_cmd_port ); ilog("hwmond : %d (port)\n", mtc_config.hwmon_cmd_port );
ilog("auth_host : %s \n", mtc_config.keystone_auth_host ); ilog("auth_host : %s \n", mtc_config.keystone_auth_host );
ilog("Barbican Port: %d (rx)\n", mtc_config.barbican_api_port );
ilog("Barbican Address : %s (tx)\n", mtc_config.barbican_api_host );
/* log system wide service based auto recovery control values */ /* log system wide service based auto recovery control values */
ilog("AR Config : %d (threshold) %d sec (retry interval)", ilog("AR Config : %d (threshold) %d sec (retry interval)",

4
mtce/src/pmon/pmonHdlr.cpp
View File

@ -423,7 +423,7 @@ void load_processes ( void )
} }
} }
pmon_send_event ( MTC_EVENT_PMON_CLEAR, &process_config[0] ) ; pmon_send_event ( MTC_EVENT_PMON_CLEAR, NULL ) ;
ilog ("Registering Processes With Kernel\n"); ilog ("Registering Processes With Kernel\n");
ilog ("---------------------------------------------------------------\n"); ilog ("---------------------------------------------------------------\n");
@ -1945,7 +1945,7 @@ void pmon_service ( pmon_ctrl_type * ctrl_ptr )
if ( want_degrade_clear () == true ) if ( want_degrade_clear () == true )
{ {
dlog ("sending degrade clear\n"); dlog ("sending degrade clear\n");
pmon_send_event ( MTC_EVENT_PMON_CLEAR, &process_config[0] ) ; pmon_send_event ( MTC_EVENT_PMON_CLEAR, NULL ) ;
} }
else else
{ {

135
mtce/src/pmon/pmonMsg.cpp
View File

@ -249,116 +249,87 @@ int pmon_send_pulse ( void )
int pmon_send_event ( unsigned int event_cmd , process_config_type * ptr ) int pmon_send_event ( unsigned int event_cmd , process_config_type * ptr )
{ {
mtc_message_type event ; mtc_message_type event ;
int rc = PASS ; int rc = PASS ;
int bytes = 0 ;
/* Don't report events while we are in reset mode */ /* Don't report events while we are in reset mode */
if ( daemon_is_file_present ( NODE_RESET_FILE ) ) if ( daemon_is_file_present ( NODE_RESET_FILE ) )
return ( PASS ); return ( PASS );
pmon_ctrl_type * ctrl_ptr = get_ctrl_ptr () ;
memset (&event, 0 , sizeof(mtc_message_type)); memset (&event, 0 , sizeof(mtc_message_type));
snprintf ( &event.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header());
if (( event_cmd == MTC_EVENT_MONITOR_READY) || event.cmd = event_cmd ;
( event_cmd == MTC_EVENT_PMON_LOG) || event.ver = MTC_CMD_FEATURE_VER__KEYVALUE_IN_BUF ;
( event_cmd == MTC_EVENT_PMON_MINOR) || event.num = 1 ;
( event_cmd == MTC_EVENT_PMON_MAJOR) || event.parm[0] = ctrl_ptr->nodetype ; /* default to node type */
( event_cmd == MTC_EVENT_PMON_CRIT ) ||
( event_cmd == MTC_EVENT_PMON_CLEAR )) string event_info = "{\"" ;
event_info.append(MTC_JSON_INV_NAME);
event_info.append("\":\"");
event_info.append(ctrl_ptr->my_hostname);
event_info.append("\",\"");
event_info.append(MTC_JSON_SERVICE);
event_info.append("\":\"");
event_info.append(MTC_SERVICE_PMOND_NAME );
if ( ( ptr != NULL ) && ( ptr->process ) )
{ {
pmon_ctrl_type * ctrl_ptr = get_ctrl_ptr () ; event_info.append("\",\"");
event_info.append(MTC_JSON_PROCESS);
event_info.append("\":\"");
event_info.append(ptr->process);
}
event_info.append( "\"}");
snprintf ( &event.hdr[0], MSG_HEADER_SIZE, "%s", get_mtce_event_header()); size_t len = event_info.length()+1 ;
snprintf ( &event.buf[0], len, "%s", event_info.data());
int bytes = ((sizeof(mtc_message_type))-(BUF_SIZE-len));
/* Set the version/revision for PMON messages. */ /* override with subfunction case */
event.ver = MTC_MSG_VERSION_15_12_GA_PMON ; if (( ptr != NULL ) &&
event.rev = MTC_MSG_REVISION_15_12_GA_PMON ; ( ctrl_ptr->subfunction != 0 ) &&
( ctrl_ptr->subfunction != ctrl_ptr->function ))
if ( ptr->process ) {
if ( ptr->subfunction != NULL )
{ {
/* We don't use the buffer for pmon events to remove it from the size */ string temp = ptr->subfunction ;
bytes = ((sizeof(mtc_message_type))-(BUF_SIZE-MAX_FILENAME_LEN)); event.parm[0]= get_host_function_mask (temp) ;
if ( ( event_cmd == MTC_EVENT_PMON_MINOR) ||
snprintf( &event.buf[0], MAX_PROCESS_NAME_LEN, "%s", ptr->process ); ( event_cmd == MTC_EVENT_PMON_MAJOR) ||
( event_cmd == MTC_EVENT_PMON_LOG) ||
/* Put the process function in parm zero of the event message */ ( event_cmd == MTC_EVENT_PMON_CRIT ) )
event.num = 1 ;
event.parm[0] = ctrl_ptr->nodetype ; /* default to node type */
if ( event_cmd == MTC_EVENT_PMON_CLEAR )
{ {
dlog ("pmond degrade clear\n" ); mlog ("%s process failed\n", ptr->process );
snprintf( &event.buf[0], MAX_PROCESS_NAME_LEN, "%s", "pmond" );
} }
else if (( event_cmd == MTC_EVENT_PMON_CRIT ) || else if (( event_cmd == MTC_EVENT_PMON_CLEAR ) && ( ptr->was_failed == true ))
( event_cmd == MTC_EVENT_PMON_MAJOR ))
{ {
wlog ("%s caused degrade assert\n", ptr->process ); ilog ("%s process recovered\n", ptr->process );
} ptr->was_failed = false ;
else if ( event_cmd == MTC_EVENT_PMON_MINOR )
{
slog ("degrade does not apply to minor\n" );
rc = FAIL_BAD_CASE ;
}
/* override with subfunction case */
if (( ctrl_ptr->subfunction != 0 ) &&
( ctrl_ptr->subfunction != ctrl_ptr->function ))
{
if ( ptr->subfunction != NULL )
{
string temp = ptr->subfunction ;
event.parm[0]= get_host_function_mask (temp) ;
if ( ( event_cmd == MTC_EVENT_PMON_MINOR) ||
( event_cmd == MTC_EVENT_PMON_MAJOR) ||
( event_cmd == MTC_EVENT_PMON_LOG) ||
( event_cmd == MTC_EVENT_PMON_CRIT ) )
{
mlog ("%s process failed\n", ptr->process );
}
else if (( event_cmd == MTC_EVENT_PMON_CLEAR ) && ( ptr->was_failed == true ))
{
ilog ("%s process recovered\n", ptr->process );
ptr->was_failed = false ;
}
}
} }
} }
} }
else if ( event_cmd == MTC_EVENT_LOOPBACK )
{
snprintf ( &event.hdr[0] , MSG_HEADER_SIZE, "%s", get_loopback_header());
/* We don't use the buffer for pmon events to remove it from the size */
bytes = ((sizeof(mtc_message_type))-(BUF_SIZE));
}
else
{
elog ("Unsupported process monitor event (%d)\n", event_cmd );
return ( FAIL_BAD_CASE );
}
event.cmd = event_cmd ;
print_mtc_message ( LOCALHOST, MTC_CMD_TX, event, get_iface_name_str(MGMNT_INTERFACE), false );
/* Send the event */ /* Send the event */
if ((rc = pmon_sock.event_sock->write((char*)&event.hdr[0], bytes)) != bytes ) if ((rc = pmon_sock.event_sock->write((char*)&event.hdr[0], bytes)) != bytes )
{ {
elog ("Message send failed. (%d)\n", rc); elog ("event message send failed (%d) (%d) (%d:%m) (%s:%d)\n",
elog ("Message: %d bytes to <%s:%d>\n", bytes, bytes, rc, errno,
pmon_sock.event_sock->get_dst_addr()->toString(), pmon_sock.event_sock->get_dst_addr()->toString(),
pmon_sock.event_sock->get_dst_addr()->getPort()); pmon_sock.event_sock->get_dst_addr()->getPort());
} }
else else
{ {
string severity = get_event_str ( event.cmd ); string severity = get_event_str ( event.cmd );
mlog ("Sending '%s' event for process '%s' to %s:%d (bytes:%d)\n", if ( ptr )
severity.c_str(), event.buf, {
pmon_sock.event_sock->get_dst_addr()->toString(), /* Only log the clear event for a specified process.
pmon_sock.event_sock->get_dst_addr()->getPort(), bytes); * Avoid logging the periodic degrade clear event. */
ilog ("%s %s sent", ctrl_ptr->my_hostname,
get_mtcNodeCommand_str(event_cmd));
}
rc = PASS ; rc = PASS ;
} }
print_mtc_message ( ctrl_ptr->my_hostname, MTC_CMD_TX, event, get_iface_name_str(MGMNT_INTERFACE), rc );
return rc ; return rc ;
} }