static void publish_to_corosync(struct stasis_message *message) { struct ast_event *event; event = stasis_message_to_event(message); if (!event) { return; } if (ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(event, AST_EVENT_IE_EID))) { /* If the event didn't originate from this server, don't send it back out. */ ast_event_destroy(event); return; } if (ast_event_get_type(event) == AST_EVENT_PING) { const struct ast_eid *eid; char buf[128] = ""; eid = ast_event_get_ie_raw(event, AST_EVENT_IE_EID); ast_eid_to_str(buf, sizeof(buf), (struct ast_eid *) eid); ast_log(LOG_NOTICE, "Sending event PING from this server with EID: '%s'\n", buf); } publish_event_to_corosync(event); }
static void cpg_deliver_cb(cpg_handle_t handle, const struct cpg_name *group_name, uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len) { struct ast_event *event; if (msg_len < ast_event_minimum_length()) { ast_debug(1, "Ignoring event that's too small. %u < %u\n", (unsigned int) msg_len, (unsigned int) ast_event_minimum_length()); return; } if (!ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(msg, AST_EVENT_IE_EID))) { /* Don't feed events back in that originated locally. */ return; } ast_rwlock_rdlock(&event_types_lock); if (!event_types[ast_event_get_type(msg)].subscribe) { /* We are not configured to subscribe to these events. */ ast_rwlock_unlock(&event_types_lock); return; } ast_rwlock_unlock(&event_types_lock); if (!(event = ast_malloc(msg_len))) { return; } memcpy(event, msg, msg_len); ast_event_queue_and_cache(event); }
static void cpg_deliver_cb(cpg_handle_t handle, const struct cpg_name *group_name, uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len) { struct ast_event *event; void (*publish_handler)(struct ast_event *) = NULL; enum ast_event_type event_type; if (msg_len < ast_event_minimum_length()) { ast_debug(1, "Ignoring event that's too small. %u < %u\n", (unsigned int) msg_len, (unsigned int) ast_event_minimum_length()); return; } if (!ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(msg, AST_EVENT_IE_EID))) { /* Don't feed events back in that originated locally. */ return; } event_type = ast_event_get_type(msg); if (event_type > AST_EVENT_TOTAL) { /* Egads, we don't support this */ return; } ast_rwlock_rdlock(&event_types_lock); publish_handler = event_types[event_type].publish_to_stasis; if (!event_types[event_type].subscribe || !publish_handler) { /* We are not configured to subscribe to these events or we have no way to publish it internally. */ ast_rwlock_unlock(&event_types_lock); return; } ast_rwlock_unlock(&event_types_lock); if (!(event = ast_malloc(msg_len))) { return; } memcpy(event, msg, msg_len); if (event_type == AST_EVENT_PING) { const struct ast_eid *eid; char buf[128] = ""; eid = ast_event_get_ie_raw(event, AST_EVENT_IE_EID); ast_eid_to_str(buf, sizeof(buf), (struct ast_eid *) eid); ast_log(LOG_NOTICE, "Got event PING from server with EID: '%s'\n", buf); } ast_debug(5, "Publishing event %s (%u) to stasis\n", ast_event_get_type_name(event), event_type); publish_handler(event); }
/*! \brief Publish a received cluster discovery \ref ast_event to \ref stasis */ static void publish_cluster_discovery_to_stasis(struct ast_event *event) { struct corosync_node *node; int id = ast_event_get_ie_uint(event, AST_EVENT_IE_NODE_ID); struct ast_eid *event_eid; ast_assert(ast_event_get_type(event) == AST_EVENT_CLUSTER_DISCOVERY); event_eid = (struct ast_eid *)ast_event_get_ie_raw(event, AST_EVENT_IE_EID); if (!ast_eid_cmp(&ast_eid_default, event_eid)) { /* Don't feed events back in that originated locally. */ return; } ao2_lock(nodes); node = ao2_find(nodes, &id, OBJ_SEARCH_KEY | OBJ_NOLOCK); if (node) { /* We already know about this node */ ao2_unlock(nodes); ao2_ref(node, -1); return; } node = corosync_node_alloc(event); if (!node) { ao2_unlock(nodes); return; } ao2_link_flags(nodes, node, OBJ_NOLOCK); ao2_unlock(nodes); publish_cluster_discovery_to_stasis_full(node, 1); ao2_ref(node, -1); /* * When we get news that someone else has joined, we need to let them * know we exist as well. */ send_cluster_notify(); }
static void publish_to_corosync(struct stasis_message *message) { cs_error_t cs_err; struct iovec iov; struct ast_event *event; event = stasis_message_to_event(message); if (!event) { return; } if (ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(event, AST_EVENT_IE_EID))) { /* If the event didn't originate from this server, don't send it back out. */ ast_event_destroy(event); return; } if (ast_event_get_type(event) == AST_EVENT_PING) { const struct ast_eid *eid; char buf[128] = ""; eid = ast_event_get_ie_raw(event, AST_EVENT_IE_EID); ast_eid_to_str(buf, sizeof(buf), (struct ast_eid *) eid); ast_log(LOG_NOTICE, "Sending event PING from this server with EID: '%s'\n", buf); } iov.iov_base = (void *)event; iov.iov_len = ast_event_get_size(event); ast_debug(5, "Publishing event %s (%u) to corosync\n", ast_event_get_type_name(event), ast_event_get_type(event)); /* The stasis subscription will only exist if we are configured to publish * these events, so just send away. */ if ((cs_err = cpg_mcast_joined(cpg_handle, CPG_TYPE_FIFO, &iov, 1)) != CS_OK) { ast_log(LOG_WARNING, "CPG mcast failed (%u)\n", cs_err); } }