static void stats_client_release (client_t *client)
{
event_listener_t *listener, **trail;
thread_mutex_lock (&_stats.listeners_lock);
listener = _stats.event_listeners;
trail = &_stats.event_listeners;
while (listener)
{
if (listener == client->shared_data)
{
stats_event_t stats_count;
char buffer [20];
*trail = listener->next;
thread_mutex_unlock (&_stats.listeners_lock);
clear_stats_queue (client);
free (listener->source);
free (listener);
client_destroy (client);
build_event (&stats_count, NULL, "stats_connections", buffer);
stats_count.action = STATS_EVENT_DEC;
process_event (&stats_count);
return;
}
trail = &listener->next;
listener = listener->next;
}
thread_mutex_unlock (&_stats.listeners_lock);
}
void stats_global_calc (void)
{
stats_event_t event;
avl_node *anode;
char buffer [VAL_BUFSIZE];
connection_stats ();
avl_tree_rlock (_stats.global_tree);
anode = avl_get_first(_stats.global_tree);
while (anode)
{
stats_node_t *node = (stats_node_t *)anode->key;
if (node->flags & STATS_REGULAR)
stats_listener_send (node->flags, "EVENT global %s %s\n", node->name, node->value);
anode = avl_get_next (anode);
}
avl_tree_unlock (_stats.global_tree);
build_event (&event, NULL, "outgoing_kbitrate", buffer);
event.flags = STATS_COUNTERS|STATS_HIDDEN;
snprintf (buffer, sizeof(buffer), "%" PRIu64,
(int64_t)global_getrate_avg (global.out_bitrate) * 8 / 1024);
process_event (&event);
}
/* simple name=tag stat create/update */
void stats_event(const char *source, const char *name, const char *value)
{
stats_event_t *event;
event = build_event (source, name, value);
if (event)
queue_global_event (event);
}
/* decrease the value in the provided stat by 1 */
void stats_event_dec(const char *source, const char *name)
{
stats_event_t event;
char buffer[VAL_BUFSIZE] = "0";
/* DEBUG2("%s on %s", name, source==NULL?"global":source); */
build_event (&event, source, name, buffer);
event.action = STATS_EVENT_DEC;
process_event (&event);
}
/* increase the value in the provided stat by 1 */
void stats_event_inc(const char *source, const char *name)
{
stats_event_t *event = build_event (source, name, NULL);
/* DEBUG2("%s on %s", name, source==NULL?"global":source); */
if (event)
{
event->action = STATS_EVENT_INC;
queue_global_event (event);
}
}
/* decrease the value in the provided stat by 1 */
void stats_event_dec(const char *source, const char *name)
{
/* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
stats_event_t *event = build_event (source, name, NULL);
if (event)
{
event->action = STATS_EVENT_DEC;
queue_global_event (event);
}
}
void stats_event_sub(const char *source, const char *name, unsigned long value)
{
stats_event_t *event = build_event (source, name, NULL);
if (event)
{
event->value = malloc (16);
snprintf(event->value, 16, "%lu", value);
event->action = STATS_EVENT_SUB;
queue_global_event (event);
}
}
// assume source stats are write locked
void stats_set (long handle, const char *name, const char *value)
{
if (handle)
{
stats_source_t *src_stats = (stats_source_t *)handle;
stats_event_t event;
build_event (&event, src_stats->source, name, (char *)value);
process_source_stat (src_stats, &event);
}
}
void stats_event_add(const char *source, const char *name, unsigned long value)
{
stats_event_t *event = build_event (source, name, NULL);
/* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
if (event)
{
event->value = malloc (16);
snprintf(event->value, 16, "%lu", value);
event->action = STATS_EVENT_ADD;
queue_global_event (event);
}
}
/* set stat with flags, name can be NULL if it applies to a whole
* source stats tree. */
void stats_event_flags (const char *source, const char *name, const char *value, int flags)
{
stats_event_t event;
build_event (&event, source, name, value);
event.flags = flags;
if (value)
event.action |= STATS_EVENT_HIDDEN;
else
event.action = STATS_EVENT_HIDDEN;
process_event (&event);
}
void stats_set_flags (long handle, const char *name, const char *value, int flags)
{
stats_source_t *src_stats = (stats_source_t *)handle;
stats_event_t event;
build_event (&event, src_stats->source, name, value);
event.flags = flags;
if (value)
event.action |= STATS_EVENT_HIDDEN;
else
event.action = STATS_EVENT_HIDDEN;
process_source_stat (src_stats, &event);
}
void stats_event_sub(const char *source, const char *name, unsigned long value)
{
stats_event_t event;
char buffer[VAL_BUFSIZE];
if (value == 0)
return;
build_event (&event, source, name, buffer);
/* DEBUG2("%s on %s", name, source==NULL?"global":source); */
snprintf (buffer, VAL_BUFSIZE, "%ld", value);
event.action = STATS_EVENT_SUB;
process_event (&event);
}
/* simple name=tag stat create/update */
void stats_event(const char *source, const char *name, const char *value)
{
stats_event_t event;
if (value && xmlCheckUTF8 ((unsigned char *)value) == 0)
{
WARN3 ("seen non-UTF8 data (%s), probably incorrect metadata (%s, %s)",
source?source:"global", name, value);
return;
}
build_event (&event, source, name, (char *)value);
process_event (&event);
}
/* simple name=tag stat create/update */
void stats_event(const char *source, const char *name, const char *value)
{
stats_event_t *event;
if (value && xmlCheckUTF8 ((unsigned char *)value) == 0)
{
ICECAST_LOG_WARN("seen non-UTF8 data, probably incorrect metadata (%s, %s)", name, value);
return;
}
event = build_event(source, name, value);
if (event)
queue_global_event(event);
}
/* make stat hidden (non-zero). name can be NULL if it applies to a whole
* source stats tree. */
void stats_event_hidden (const char *source, const char *name, int hidden)
{
stats_event_t *event;
const char *str = NULL;
if (hidden)
str = "";
event = build_event (source, name, str);
if (event)
{
event->action = STATS_EVENT_HIDDEN;
queue_global_event (event);
}
}
PREDEM_CURL_CODE predem_curl_send_event(const char *name, const char* json_string){
CURL *curl;
CURLcode res;
struct curl_slist *list = NULL;
char url_buff[512];
if (inited == 0) {
return PREDEM_CURL_NOT_INIT;
}
if (json_string == NULL || name == NULL) {
return PREDEM_CURL_INVALID_DATA;
}
/* get a curl handle */
curl = curl_easy_init();
if (curl == NULL ) {
return PREDEM_CURL_NO_MEMORY;
}
memset(url_buff, 0, sizeof(url_buff));
int pos = 0;
if (has_http(g_domain) == 0) {
memcpy(url_buff, "http://", 7);
pos += 7;
}
snprintf(url_buff+pos, sizeof(url_buff)-pos, "%s/v2/%s/custom-events", g_domain, g_app_id);
curl_easy_setopt(curl, CURLOPT_URL, url_buff);
curl_easy_setopt(curl, CURLOPT_USERAGENT, g_UA);
list = curl_slist_append(list, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
cJSON* event = build_event(name, json_string);
const char* c = cJSON_PrintUnformatted(event);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen(c));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, c);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
curl_slist_free_all(list);
cJSON_free((void*)c);
cJSON_Delete(event);
if(res != CURLE_OK) {
return (PREDEM_CURL_CODE)res;
}
return PREDEM_CURL_OK;
}
static void
lookup_find(dns_lookup_t *lookup, dns_fetchevent_t *event) {
isc_result_t result;
isc_boolean_t want_restart;
isc_boolean_t send_event;
dns_name_t *name, *fname, *prefix;
dns_fixedname_t foundname, fixed;
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned int nlabels;
int order;
dns_namereln_t namereln;
dns_rdata_cname_t cname;
dns_rdata_dname_t dname;
REQUIRE(VALID_LOOKUP(lookup));
LOCK(&lookup->lock);
result = ISC_R_SUCCESS;
name = dns_fixedname_name(&lookup->name);
do {
lookup->restarts++;
want_restart = ISC_FALSE;
send_event = ISC_TRUE;
if (event == NULL && !lookup->canceled) {
dns_fixedname_init(&foundname);
fname = dns_fixedname_name(&foundname);
INSIST(!dns_rdataset_isassociated(&lookup->rdataset));
INSIST(!dns_rdataset_isassociated
(&lookup->sigrdataset));
/*
* If we have restarted then clear the old node. */
if (lookup->event->node != NULL) {
INSIST(lookup->event->db != NULL);
dns_db_detachnode(lookup->event->db,
&lookup->event->node);
}
if (lookup->event->db != NULL)
dns_db_detach(&lookup->event->db);
result = view_find(lookup, fname);
if (result == ISC_R_NOTFOUND) {
/*
* We don't know anything about the name.
* Launch a fetch.
*/
if (lookup->event->node != NULL) {
INSIST(lookup->event->db != NULL);
dns_db_detachnode(lookup->event->db,
&lookup->event->node);
}
if (lookup->event->db != NULL)
dns_db_detach(&lookup->event->db);
result = start_fetch(lookup);
if (result == ISC_R_SUCCESS)
send_event = ISC_FALSE;
goto done;
}
} else if (event != NULL) {
result = event->result;
fname = dns_fixedname_name(&event->foundname);
dns_resolver_destroyfetch(&lookup->fetch);
INSIST(event->rdataset == &lookup->rdataset);
INSIST(event->sigrdataset == &lookup->sigrdataset);
} else
fname = NULL; /* Silence compiler warning. */
/*
* If we've been canceled, forget about the result.
*/
if (lookup->canceled)
result = ISC_R_CANCELED;
switch (result) {
case ISC_R_SUCCESS:
result = build_event(lookup);
if (event == NULL)
break;
if (event->db != NULL)
dns_db_attach(event->db, &lookup->event->db);
if (event->node != NULL)
dns_db_attachnode(lookup->event->db,
event->node,
&lookup->event->node);
break;
case DNS_R_CNAME:
/*
* Copy the CNAME's target into the lookup's
* query name and start over.
*/
result = dns_rdataset_first(&lookup->rdataset);
if (result != ISC_R_SUCCESS)
break;
dns_rdataset_current(&lookup->rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &cname, NULL);
dns_rdata_reset(&rdata);
if (result != ISC_R_SUCCESS)
break;
result = dns_name_copy(&cname.cname, name, NULL);
dns_rdata_freestruct(&cname);
if (result == ISC_R_SUCCESS) {
want_restart = ISC_TRUE;
send_event = ISC_FALSE;
}
break;
case DNS_R_DNAME:
namereln = dns_name_fullcompare(name, fname, &order,
&nlabels);
INSIST(namereln == dns_namereln_subdomain);
/*
* Get the target name of the DNAME.
*/
result = dns_rdataset_first(&lookup->rdataset);
if (result != ISC_R_SUCCESS)
break;
dns_rdataset_current(&lookup->rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &dname, NULL);
dns_rdata_reset(&rdata);
if (result != ISC_R_SUCCESS)
break;
/*
* Construct the new query name and start over.
*/
dns_fixedname_init(&fixed);
prefix = dns_fixedname_name(&fixed);
dns_name_split(name, nlabels, prefix, NULL);
result = dns_name_concatenate(prefix, &dname.dname,
name, NULL);
dns_rdata_freestruct(&dname);
if (result == ISC_R_SUCCESS) {
want_restart = ISC_TRUE;
send_event = ISC_FALSE;
}
break;
default:
send_event = ISC_TRUE;
}
if (dns_rdataset_isassociated(&lookup->rdataset))
dns_rdataset_disassociate(&lookup->rdataset);
if (dns_rdataset_isassociated(&lookup->sigrdataset))
dns_rdataset_disassociate(&lookup->sigrdataset);
done:
if (event != NULL) {
if (event->node != NULL)
dns_db_detachnode(event->db, &event->node);
if (event->db != NULL)
dns_db_detach(&event->db);
isc_event_free(ISC_EVENT_PTR(&event));
}
/*
* Limit the number of restarts.
*/
if (want_restart && lookup->restarts == MAX_RESTARTS) {
want_restart = ISC_FALSE;
result = ISC_R_QUOTA;
send_event = ISC_TRUE;
}
} while (want_restart);
if (send_event) {
lookup->event->result = result;
lookup->event->ev_sender = lookup;
isc_task_sendanddetach(&lookup->task,
(isc_event_t **)(void *)&lookup->event);
dns_view_detach(&lookup->view);
}
UNLOCK(&lookup->lock);
}
/* factoring out code for stats loops
** this function copies all stats to queue, and registers
*/
static void _register_listener (client_t *client)
{
event_listener_t *listener = client->shared_data;
avl_node *node;
stats_event_t stats_count;
refbuf_t *refbuf;
size_t size = 8192;
char buffer[20];
build_event (&stats_count, NULL, "stats_connections", buffer);
stats_count.action = STATS_EVENT_INC;
process_event (&stats_count);
/* first we fill our queue with the current stats */
refbuf = refbuf_new (size);
refbuf->len = 0;
/* the global stats */
avl_tree_rlock (_stats.global_tree);
node = avl_get_first(_stats.global_tree);
while (node)
{
stats_node_t *stat = node->key;
if (stat->flags & listener->mask)
{
if (_append_to_buffer (refbuf, size, "EVENT global %s %s\n", stat->name, stat->value) < 0)
{
_add_node_to_stats_client (client, refbuf);
refbuf = refbuf_new (size);
refbuf->len = 0;
continue;
}
}
node = avl_get_next(node);
}
avl_tree_unlock (_stats.global_tree);
/* now the stats for each source */
avl_tree_rlock (_stats.source_tree);
node = avl_get_first(_stats.source_tree);
while (node)
{
avl_node *node2;
stats_node_t *metadata_stat = NULL;
stats_source_t *snode = (stats_source_t *)node->key;
if (snode->flags & listener->mask)
{
stats_node_t *ct = _find_node (snode->stats_tree, "content-type");
const char *type = "audio/mpeg";
if (ct)
type = ct->name;
if (_append_to_buffer (refbuf, size, "NEW %s %s\n", type, snode->source) < 0)
{
_add_node_to_stats_client (client, refbuf);
refbuf = refbuf_new (size);
refbuf->len = 0;
continue;
}
}
node = avl_get_next(node);
avl_tree_rlock (snode->stats_tree);
node2 = avl_get_first(snode->stats_tree);
while (node2)
{
stats_node_t *stat = node2->key;
if (metadata_stat == NULL && strcmp (stat->name, "metadata_updated") == 0)
metadata_stat = stat;
else if (stat->flags & listener->mask)
{
if (_append_to_buffer (refbuf, size, "EVENT %s %s %s\n", snode->source, stat->name, stat->value) < 0)
{
_add_node_to_stats_client (client, refbuf);
refbuf = refbuf_new (size);
refbuf->len = 0;
continue;
}
}
node2 = avl_get_next (node2);
}
while (metadata_stat)
{
if (_append_to_buffer (refbuf, size, "EVENT %s %s %s\n", snode->source, metadata_stat->name, metadata_stat->value) < 0)
{
_add_node_to_stats_client (client, refbuf);
refbuf = refbuf_new (size);
refbuf->len = 0;
continue;
}
break;
}
avl_tree_unlock (snode->stats_tree);
}
avl_tree_unlock (_stats.source_tree);
_add_node_to_stats_client (client, refbuf);
/* now we register to receive future event notices */
thread_mutex_lock (&_stats.listeners_lock);
listener->next = _stats.event_listeners;
_stats.event_listeners = listener;
thread_mutex_unlock (&_stats.listeners_lock);
}
