void handler_try(void)
{
Pthread_mutex_trylock(&mp);
cnt++;
fprintf(stdout, "cnt[%d]\n", cnt);
Pthread_mutex_unlock(&mp);
}
void
cerebrod_event_update_node_received_time(struct cerebrod_node_data *nd,
u_int32_t received_time)
{
struct cerebrod_event_node_timeout *ntd;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(nd);
assert(received_time);
if (!event_index)
return;
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&nd->node_data_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
Pthread_mutex_lock(&event_node_timeout_data_lock);
if ((ntd = Hash_find(event_node_timeout_data_index, nd->nodename)))
{
ntd->last_received_time = received_time;
ntd->timeout_occurred = 0;
}
Pthread_mutex_unlock(&event_node_timeout_data_lock);
}
/*
* cerebrod_monitor_modules_update
*
* Send metric data to the appropriate monitor modules, if necessary.
* The struct cerebrod_node_data lock should already be locked.
*/
void
cerebrod_monitor_modules_update(const char *nodename,
struct cerebrod_node_data *nd,
const char *metric_name,
struct cerebrod_message_metric *mm)
{
struct cerebrod_monitor_module_info *monitor_module;
struct cerebrod_monitor_module_list *ml;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(nodename && nd && metric_name && mm);
if (!monitor_index)
return;
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&nd->node_data_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
if ((ml = Hash_find(monitor_index, metric_name)))
{
ListIterator itr = NULL;
Pthread_mutex_lock(&(ml->monitor_list_lock));
itr = List_iterator_create(ml->monitor_list);
Pthread_mutex_unlock(&(ml->monitor_list_lock));
while ((monitor_module = list_next(itr)))
{
Pthread_mutex_lock(&monitor_module->monitor_lock);
monitor_module_metric_update(monitor_handle,
monitor_module->index,
nodename,
metric_name,
mm->metric_value_type,
mm->metric_value_len,
mm->metric_value);
Pthread_mutex_unlock(&monitor_module->monitor_lock);
}
Pthread_mutex_lock(&(ml->monitor_list_lock));
List_iterator_destroy(itr);
Pthread_mutex_unlock(&(ml->monitor_list_lock));
}
}
static void
_delete_event_connection_fd(int fd)
{
struct cerebrod_event_connection_data *ecd;
ListIterator eitr;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(fd >= 0);
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&event_connections_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
eitr = List_iterator_create(event_connections);
while ((ecd = list_next(eitr)))
{
if (ecd->fd == fd)
{
List connections;
if ((connections = Hash_find(event_connections_index,
ecd->event_name)))
{
ListIterator citr;
int *fdPtr;
citr = List_iterator_create(connections);
while ((fdPtr = list_next(citr)))
{
if (*fdPtr == fd)
{
List_delete(citr);
break;
}
}
List_iterator_destroy(citr);
}
List_delete(eitr);
break;
}
}
List_iterator_destroy(eitr);
}
void
cerebrod_speaker_data_metric_list_sort(void)
{
#if CEREBRO_DEBUG
#if !WITH_CEREBROD_NO_THREADS
int rv;
#endif /* !WITH_CEREBROD_NO_THREADS */
#endif /* CEREBRO_DEBUG */
assert(metric_list);
#if CEREBRO_DEBUG
#if !WITH_CEREBROD_NO_THREADS
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&metric_list_lock);
if (rv != EBUSY)
CEREBRO_EXIT(("mutex not locked: rv=%d", rv));
#endif /* !WITH_CEREBROD_NO_THREADS */
#endif /* CEREBRO_DEBUG */
List_sort(metric_list, _next_call_time_cmp);
}
void
cerebrod_rehash(hash_t *old_hash,
int *hash_size,
int hash_size_increment,
int hash_num,
pthread_mutex_t *hash_mutex)
{
hash_t new_hash;
assert(old_hash && hash_size && hash_size_increment && hash_num);
#if CEREBRO_DEBUG
/* Should be called with lock already set */
if (hash_mutex)
{
int rv = Pthread_mutex_trylock(hash_mutex);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
}
#endif /* CEREBRO_DEBUG */
*hash_size += hash_size_increment;
new_hash = Hash_create(*hash_size,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
(hash_del_f)_Free);
if (Hash_for_each(*old_hash, _hash_reinsert, &new_hash) != hash_num)
CEREBROD_EXIT(("invalid reinsert: hash_num=%d", hash_num));
if (Hash_remove_if(*old_hash, _hash_removeall, NULL) != hash_num)
CEREBROD_EXIT(("invalid removeall: hash_num=%d", hash_num));
Hash_destroy(*old_hash);
*old_hash = new_hash;
}
/*
* _event_node_timeout_data_add
*
* Create entries for the event_node_timeout_data list and index
*
* Returns 0 on success, -1 on error
*/
static int
_event_node_timeout_data_add(const char *nodename, u_int32_t time_now)
{
struct cerebrod_event_node_timeout_data *ntd;
#if CEREBRO_DEBUG
int rv;
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&event_node_timeout_data_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
ntd = (struct cerebrod_event_node_timeout_data *)Malloc(sizeof(struct cerebrod_event_node_timeout_data));
ntd->nodename = (char *)nodename;
ntd->last_received_time = time_now;
ntd->timeout_occurred = 0;
List_append(event_node_timeout_data, ntd);
Hash_insert(event_node_timeout_data_index, ntd->nodename, ntd);
event_node_timeout_data_index_numnodes++;
return 0;
}
void
cerebrod_event_add_node_timeout_data(struct cerebrod_node_data *nd,
u_int32_t received_time)
{
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(nd);
assert(received_time);
if (!event_index)
return;
assert(event_node_timeout_data_index);
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&listener_data_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
Pthread_mutex_lock(&event_node_timeout_data_lock);
/* Re-hash if our hash is getting too small */
if ((event_node_timeout_data_index_numnodes + 1) > (event_node_timeout_data_index_size*2))
cerebrod_rehash(&event_node_timeout_data_index,
&event_node_timeout_data_index_size,
EVENT_NODE_TIMEOUT_SIZE_INCREMENT,
event_node_timeout_data_index_numnodes,
&event_node_timeout_data_lock);
_event_node_timeout_data_add(nd->nodename, received_time);
event_node_timeout_data_index_numnodes++;
Pthread_mutex_unlock(&event_node_timeout_data_lock);
}
void
cerebrod_message_dump(struct cerebrod_message *msg)
{
int i;
#if !WITH_CEREBROD_NO_THREADS
int rv;
#endif /* !WITH_CEREBROD_NO_THREADS */
assert(msg);
if (!conf.debug)
return;
#if !WITH_CEREBROD_NO_THREADS
rv = Pthread_mutex_trylock(&debug_output_mutex);
if (rv != EBUSY)
{
fprintf(stderr, "(%s, %s, %d): mutex not locked: rv=%d",
__FILE__, __FUNCTION__, __LINE__, rv);
exit(1);
}
#endif /* !WITH_CEREBROD_NO_THREADS */
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Cerebrod Message:\n");
fprintf(stderr, "* -------------------\n");
fprintf(stderr, "* version: %d\n", msg->version);
fprintf(stderr, "* nodename: \"%s\"\n", msg->nodename);
fprintf(stderr, "* metrics_len: %d\n", msg->metrics_len);
for (i = 0; i < msg->metrics_len; i++)
{
char *buf;
fprintf(stderr, "* %s: metric type = %d, len = %d ",
msg->metrics[i]->metric_name,
msg->metrics[i]->metric_value_type,
msg->metrics[i]->metric_value_len);
switch(msg->metrics[i]->metric_value_type)
{
case CEREBRO_DATA_VALUE_TYPE_NONE:
break;
case CEREBRO_DATA_VALUE_TYPE_INT32:
fprintf(stderr, "value = %d",
*((int32_t *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_U_INT32:
fprintf(stderr, "value = %u",
*((u_int32_t *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_FLOAT:
fprintf(stderr, "value = %f",
*((float *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_DOUBLE:
fprintf(stderr, "value = %f",
*((double *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_STRING:
/* Watch for NUL termination */
buf = Malloc(msg->metrics[i]->metric_value_len + 1);
memset(buf, '\0', msg->metrics[i]->metric_value_len + 1);
memcpy(buf,
msg->metrics[i]->metric_value,
msg->metrics[i]->metric_value_len);
fprintf(stderr, "value = %s", buf);
Free(buf);
break;
#if SIZEOF_LONG == 4
case CEREBRO_DATA_VALUE_TYPE_INT64:
fprintf(stderr, "value = %lld",
*((int64_t *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_U_INT64:
fprintf(stderr, "value = %llu",
*((u_int64_t *)msg->metrics[i]->metric_value));
break;
#else /* SIZEOF_LONG == 8 */
case CEREBRO_DATA_VALUE_TYPE_INT64:
fprintf(stderr, "value = %ld",
*((int64_t *)msg->metrics[i]->metric_value));
break;
case CEREBRO_DATA_VALUE_TYPE_U_INT64:
fprintf(stderr, "value = %lu",
*((u_int64_t *)msg->metrics[i]->metric_value));
break;
#endif /* SIZEOF_LONG == 8 */
default:
break;
}
fprintf(stderr, "\n");
}
fprintf(stderr, "**************************************\n");
}
/*
* _setup_metric_modules
*
* Setup metric modules. Under almost any circumstance, don't return a
* -1 error, cerebro can go on without loading metric modules.
*
* Returns 1 if modules are loaded, 0 if not, -1 on error
*/
static int
_setup_metric_modules(void)
{
int i;
#if CEREBRO_DEBUG
#if !WITH_CEREBROD_NO_THREADS
int rv;
#endif /* !WITH_CEREBROD_NO_THREADS */
#endif /* CEREBRO_DEBUG */
assert(metric_list);
#if CEREBRO_DEBUG
#if !WITH_CEREBROD_NO_THREADS
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&metric_list_lock);
if (rv != EBUSY)
CEREBRO_EXIT(("mutex not locked: rv=%d", rv));
#endif /* !WITH_CEREBROD_NO_THREADS */
#endif /* CEREBRO_DEBUG */
if (!(metric_handle = metric_modules_load()))
{
CEREBRO_DBG(("metric_modules_load"));
goto cleanup;
}
if ((metric_handle_count = metric_modules_count(metric_handle)) < 0)
{
CEREBRO_DBG(("metric_module_count failed"));
goto cleanup;
}
if (!metric_handle_count)
{
#if CEREBRO_DEBUG
if (conf.debug && conf.speak_debug)
{
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_lock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* No Metric Modules Found\n");
fprintf(stderr, "**************************************\n");
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_unlock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
}
#endif /* CEREBRO_DEBUG */
goto cleanup;
}
for (i = 0; i < metric_handle_count; i++)
{
struct cerebrod_speaker_metric_info *metric_info;
#if !WITH_CEREBROD_NO_THREADS
Cerebro_metric_thread_pointer threadPtr;
#endif /* !WITH_CEREBROD_NO_THREADS */
char *module_name, *metric_name;
int metric_period;
u_int32_t metric_flags;
module_name = metric_module_name(metric_handle, i);
if (conf.metric_module_exclude_len)
{
int found_exclude = 0;
int j;
for (j = 0; j < conf.metric_module_exclude_len; j++)
{
if (!strcasecmp(conf.metric_module_exclude[j], module_name))
{
found_exclude++;
break;
}
}
if (found_exclude)
{
#if CEREBRO_DEBUG
if (conf.debug && conf.speak_debug)
{
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_lock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Skip Metric Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_unlock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
}
#endif /* CEREBRO_DEBUG */
CEREBRO_ERR(("Dropping metric module: %s", module_name));
continue;
}
}
#if CEREBRO_DEBUG
if (conf.debug && conf.speak_debug)
{
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_lock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Setup Metric Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
#if !WITH_CEREBROD_NO_THREADS
Pthread_mutex_unlock(&debug_output_mutex);
#endif /* !WITH_CEREBROD_NO_THREADS */
}
#endif /* CEREBRO_DEBUG */
if (metric_module_setup(metric_handle, i) < 0)
{
CEREBRO_DBG(("metric_module_setup: %s", module_name));
continue;
}
if (!(metric_name = metric_module_get_metric_name(metric_handle, i)))
{
CEREBRO_DBG(("metric_module_get_metric_name: %s", module_name));
metric_module_cleanup(metric_handle, i);
continue;
}
if (metric_module_get_metric_period(metric_handle, i, &metric_period) < 0)
{
CEREBRO_DBG(("metric_module_get_metric_period: %s", module_name));
metric_module_cleanup(metric_handle, i);
continue;
}
if (metric_module_get_metric_flags(metric_handle, i, &metric_flags) < 0)
{
CEREBRO_DBG(("metric_module_get_metric_flags: %s", module_name));
metric_module_cleanup(metric_handle, i);
continue;
}
if (metric_flags & CEREBRO_METRIC_MODULE_FLAGS_SEND_ON_PERIOD
&& metric_period <= 0)
{
CEREBRO_DBG(("metric module period invalid: %s", module_name));
metric_module_cleanup(metric_handle, i);
continue;
}
if (metric_module_send_message_function_pointer(metric_handle, i, &cerebrod_send_message) < 0)
{
CEREBRO_DBG(("metric_module_send_message_function_pointer: %s", module_name));
metric_module_cleanup(metric_handle, i);
continue;
}
metric_info = Malloc(sizeof(struct cerebrod_speaker_metric_info));
/* No need to Strdup() the name in this case */
metric_info->metric_name = metric_name;
metric_info->metric_origin = CEREBROD_METRIC_SPEAKER_ORIGIN_MODULE;
metric_info->metric_period = metric_period;
metric_info->metric_flags = metric_flags;
metric_info->index = i;
/*
* If metric period is < 0, it presumably never will be sent
* (metric is likely handled by a metric_thread), so set
* next_call_time to UINT_MAX.
*
* If this is a metric that will be piggy-backed on heartbeats,
* then initialize next_call_time to 0, so the data is sent on
* the first heartbeat
*
* If this is a metric that will not be piggy-backed on
* heartbeats, set the next_call_time to UINT_MAX. Let the
* speaker logic decide when packets should be sent.
*/
if (metric_info->metric_period < 0
|| metric_info->metric_flags & CEREBRO_METRIC_MODULE_FLAGS_SEND_ON_PERIOD)
metric_info->next_call_time = UINT_MAX;
else
metric_info->next_call_time = 0;
List_append(metric_list, metric_info);
metric_list_size++;
#if !WITH_CEREBROD_NO_THREADS
if ((threadPtr = metric_module_get_metric_thread(metric_handle, i)))
{
pthread_t thread;
pthread_attr_t attr;
Pthread_attr_init(&attr);
Pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
Pthread_attr_setstacksize(&attr, CEREBROD_THREAD_STACKSIZE);
Pthread_create(&thread, &attr, threadPtr, NULL);
Pthread_attr_destroy(&attr);
}
#endif /* !WITH_CEREBROD_NO_THREADS */
}
if (!metric_list_size)
goto cleanup;
cerebrod_speaker_data_metric_list_sort();
return 1;
cleanup:
if (metric_handle)
{
/* unload will call module cleanup functions */
metric_modules_unload(metric_handle);
metric_handle = NULL;
metric_handle_count = 0;
}
metric_list_size = 0;
return 0;
}
void
cerebrod_event_modules_update(const char *nodename,
struct cerebrod_node_data *nd,
const char *metric_name,
struct cerebrod_message_metric *mm)
{
struct cerebrod_event_module_info *event_module;
struct cerebrod_event_module_list *el;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(nodename && nd && metric_name && mm);
if (!event_index)
return;
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&nd->node_data_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
/*
* This function may be called by multiple threads by the listener.
*
* The event_index is setup at the beginning and is only read, not
* written to. However, the lists stored inside the event_index
* need to called w/ thread safety (due to the nature of the list
* API).
*
*/
if ((el = Hash_find(event_index, metric_name)))
{
struct cerebro_event *event = NULL;
ListIterator itr = NULL;
int rv;
Pthread_mutex_lock(&(el->event_list_lock));
itr = List_iterator_create(el->event_list);
Pthread_mutex_unlock(&(el->event_list_lock));
while ((event_module = list_next(itr)))
{
Pthread_mutex_lock(&event_module->event_lock);
if ((rv = event_module_metric_update(event_handle,
event_module->index,
nodename,
metric_name,
mm->metric_value_type,
mm->metric_value_len,
mm->metric_value,
&event)) < 0)
{
CEREBROD_DBG(("event_module_metric_update"));
goto loop_next;
}
if (rv && event)
cerebrod_queue_event(event, event_module->index);
loop_next:
Pthread_mutex_unlock(&event_module->event_lock);
}
Pthread_mutex_lock(&(el->event_list_lock));
List_iterator_destroy(itr);
Pthread_mutex_unlock(&(el->event_list_lock));
}
}
/*
* Under almost any circumstance, don't return a -1 error, cerebro can
* go on without loading monitor modules. The listener_data_init_lock
* should already be set.
*/
int
cerebrod_event_modules_setup(void)
{
int i, event_module_count, event_index_len, event_index_count = 0;
struct cerebrod_event_module_list *el = NULL;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
assert(listener_data);
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&listener_data_init_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
if (!conf.event_server)
return 0;
if (!(event_handle = event_modules_load()))
{
CEREBROD_DBG(("event_modules_load"));
goto cleanup;
}
if ((event_module_count = event_modules_count(event_handle)) < 0)
{
CEREBROD_DBG(("event_modules_count"));
goto cleanup;
}
if (!event_module_count)
{
if (conf.debug && conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* No Event Modules Found\n");
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
goto cleanup;
}
/* Each event module may want multiple metrics and/or offer multiple
* event names. We'll assume there will never be more than 2 per
* event module, and that will be enough to avoid all hash
* collisions.
*/
event_index_len = event_module_count * 2;
event_index = Hash_create(event_index_len,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
(hash_del_f)_cerebrod_event_module_list_destroy);
event_names = List_create((ListDelF)_Free);
event_module_timeouts = List_create((ListDelF)_cerebrod_event_module_timeout_data_destroy);
event_module_timeout_index = Hash_create(event_module_count,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
(hash_del_f)list_destroy);
for (i = 0; i < event_module_count; i++)
{
struct cerebrod_event_module *event_module;
char *module_name, *module_metric_names, *module_event_names;
char *metricPtr, *metricbuf;
char *eventnamePtr, *eventbuf;
int timeout;
module_name = event_module_name(event_handle, i);
if (conf.event_module_exclude_len)
{
int found_exclude = 0;
int j;
for (j = 0; j < conf.event_module_exclude_len; j++)
{
if (!strcasecmp(conf.event_module_exclude[j], module_name))
{
found_exclude++;
break;
}
}
if (found_exclude)
{
if (conf.debug && conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Skip Event Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
CEREBROD_ERR(("Dropping event module: %s", module_name));
continue;
}
}
if (conf.debug && conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Setup Event Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
if (event_module_setup(event_handle, i) < 0)
{
CEREBROD_DBG(("event_module_setup failed: %s", module_name));
continue;
}
if (!(module_metric_names = event_module_metric_names(event_handle, i)) < 0)
{
CEREBROD_DBG(("event_module_metric_names failed: %s", module_name));
event_module_cleanup(event_handle, i);
continue;
}
if (!(module_event_names = event_module_event_names(event_handle, i)) < 0)
{
CEREBROD_DBG(("event_module_event_names failed: %s", module_name));
event_module_cleanup(event_handle, i);
continue;
}
if ((timeout = event_module_timeout_length(event_handle, i)) < 0)
{
CEREBROD_DBG(("event_module_timeout_length failed: %s", module_name));
event_module_cleanup(event_handle, i);
continue;
}
event_module = Malloc(sizeof(struct cerebrod_event_module_info));
event_module->metric_names = Strdup(module_metric_names);
event_module->event_names = Strdup(module_event_names);
event_module->index = i;
Pthread_mutex_init(&(event_module->event_lock), NULL);
/* The monitoring module may support multiple metrics */
metricPtr = strtok_r(event_module->metric_names, ",", &metricbuf);
while (metricPtr)
{
if (!(el = Hash_find(event_index, metricPtr)))
{
el = (struct cerebrod_event_module_list *)Malloc(sizeof(struct cerebrod_event_module_list));
el->event_list = List_create((ListDelF)_cerebrod_event_module_info_destroy);
Pthread_mutex_init(&(el->event_list_lock), NULL);
List_append(el->event_list, event_module);
Hash_insert(event_index, metricPtr, el);
event_index_count++;
}
else
List_append(el->event_list, event_module);
metricPtr = strtok_r(NULL, ",", &metricbuf);
}
/* The monitoring module may support multiple event names */
eventnamePtr = strtok_r(event_module->event_names, ",", &eventbuf);
while (eventnamePtr)
{
if (!list_find_first(event_names,
(ListFindF)_cerebrod_name_strcmp,
eventnamePtr))
{
List_append(event_names, eventnamePtr);
if (conf.debug && conf.event_server_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Event Name: %s\n", eventnamePtr);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
}
eventnamePtr = strtok_r(NULL, ",", &eventbuf);
}
if (timeout)
{
struct cerebrod_event_module_timeout_data *mtd;
List modules_list;
if (!(mtd = List_find_first(event_module_timeouts,
_event_module_timeout_data_find_callback,
&timeout)))
{
char strbuf[64];
mtd = (struct cerebrod_event_module_timeout_data *)Malloc(sizeof(struct cerebrod_event_module_timeout_data));
mtd->timeout = timeout;
snprintf(strbuf, 64, "%d", timeout);
mtd->timeout_str = Strdup(strbuf);
List_append(event_module_timeouts, mtd);
if (timeout < event_module_timeout_min)
event_module_timeout_min = timeout;
}
if (!(modules_list = Hash_find(event_module_timeout_index,
mtd->timeout_str)))
{
modules_list = List_create((ListDelF)NULL);
List_append(modules_list, event_module);
Hash_insert(event_module_timeout_index,
mtd->timeout_str,
modules_list);
}
else
List_append(modules_list, event_module);
}
}
List_sort(event_module_timeouts, _event_module_timeout_data_compare);
if (!event_index_count)
goto cleanup;
if (_setup_event_node_timeout_data() < 0)
goto cleanup;
/*
* Since the cerebrod listener is started before any of the event
* threads (node_timeout, queue_monitor, server), this must be
* created in here (which is called by the listener) to avoid a
* possible race of modules creating events before the event_queue
* is created.
*/
event_queue = List_create((ListDelF)cerebrod_event_to_send_destroy);
return 1;
cleanup:
if (event_handle)
{
event_modules_unload(event_handle);
event_handle = NULL;
}
if (event_index)
{
Hash_destroy(event_index);
event_index = NULL;
}
if (event_names)
{
List_destroy(event_names);
event_names = NULL;
}
return 0;
}
/*
* Under almost any circumstance, don't return a -1 error, cerebro can
* go on without loading monitor modules. The listener_data_init_lock
* should already be set.
*/
int
cerebrod_monitor_modules_setup(void)
{
int i, monitor_module_count, monitor_index_len, monitor_index_count = 0;
struct cerebrod_monitor_module_list *ml = NULL;
#if CEREBRO_DEBUG
int rv;
#endif /* CEREBRO_DEBUG */
#if CEREBRO_DEBUG
/* Should be called with lock already set */
rv = Pthread_mutex_trylock(&listener_data_init_lock);
if (rv != EBUSY)
CEREBROD_EXIT(("mutex not locked: rv=%d", rv));
#endif /* CEREBRO_DEBUG */
if (!(monitor_handle = monitor_modules_load()))
{
CEREBROD_DBG(("monitor_modules_load"));
goto cleanup;
}
if ((monitor_module_count = monitor_modules_count(monitor_handle)) < 0)
{
CEREBROD_DBG(("monitor_modules_count"));
goto cleanup;
}
if (!monitor_module_count)
{
if (conf.debug && conf.listen_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* No Monitor Modules Found\n");
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
goto cleanup;
}
/* Each monitor module may wish to monitor multiple metrics. We'll
* assume there will never be more than 2 metrics per monitor module, and
* that will be enough to avoid all hash collisions.
*/
monitor_index_len = monitor_module_count * 2;
monitor_index = Hash_create(monitor_index_len,
(hash_key_f)hash_key_string,
(hash_cmp_f)strcmp,
(hash_del_f)_cerebrod_monitor_module_list_destroy);
for (i = 0; i < monitor_module_count; i++)
{
struct cerebrod_monitor_module_info *monitor_module;
char *module_name, *metric_names;
char *metricPtr, *metricbuf;
module_name = monitor_module_name(monitor_handle, i);
if (conf.monitor_module_exclude_len)
{
int found_exclude = 0;
int j;
for (j = 0; j < conf.monitor_module_exclude_len; j++)
{
if (!strcasecmp(conf.monitor_module_exclude[j], module_name))
{
found_exclude++;
break;
}
}
if (found_exclude)
{
if (conf.debug && conf.listen_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Skip Monitor Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
CEREBROD_ERR(("Dropping monitor module: %s", module_name));
continue;
}
}
if (conf.debug && conf.listen_debug)
{
Pthread_mutex_lock(&debug_output_mutex);
fprintf(stderr, "**************************************\n");
fprintf(stderr, "* Setup Monitor Module: %s\n", module_name);
fprintf(stderr, "**************************************\n");
Pthread_mutex_unlock(&debug_output_mutex);
}
if (monitor_module_setup(monitor_handle, i) < 0)
{
CEREBROD_DBG(("monitor_module_setup failed: %s", module_name));
continue;
}
if (!(metric_names = monitor_module_metric_names(monitor_handle, i)) < 0)
{
CEREBROD_DBG(("monitor_module_metric_names failed: %s", module_name));
monitor_module_cleanup(monitor_handle, i);
continue;
}
monitor_module = Malloc(sizeof(struct cerebrod_monitor_module_info));
monitor_module->metric_names = Strdup(metric_names);
monitor_module->index = i;
Pthread_mutex_init(&(monitor_module->monitor_lock), NULL);
/* The monitoring module may support multiple metrics */
metricPtr = strtok_r(monitor_module->metric_names, ",", &metricbuf);
while (metricPtr)
{
if (!(ml = Hash_find(monitor_index, metricPtr)))
{
ml = (struct cerebrod_monitor_module_list *)Malloc(sizeof(struct cerebrod_monitor_module_list));
ml->monitor_list = List_create((ListDelF)_cerebrod_monitor_module_info_destroy);
Pthread_mutex_init(&(ml->monitor_list_lock), NULL);
List_append(ml->monitor_list, monitor_module);
Hash_insert(monitor_index, metricPtr, ml);
monitor_index_count++;
}
else
List_append(ml->monitor_list, monitor_module);
metricPtr = strtok_r(NULL, ",", &metricbuf);
}
}
if (!monitor_index_count)
goto cleanup;
return 1;
cleanup:
if (monitor_handle)
{
monitor_modules_unload(monitor_handle);
monitor_handle = NULL;
}
if (monitor_index)
{
Hash_destroy(monitor_index);
monitor_index = NULL;
}
return 0;
}
