stats.c 30.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/* Icecast
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright 2000-2004, Jack Moffitt <jack@xiph.org, 
 *                      Michael Smith <msmith@xiph.org>,
 *                      oddsock <oddsock@xiph.org>,
 *                      Karl Heyes <karl@xiph.org>
 *                      and others (see AUTHORS for details).
11
 * Copyright 2012-2014, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
12 13
 */

14 15 16 17
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

Jack Moffitt's avatar
Jack Moffitt committed
18 19 20 21
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
22
#include <ctype.h>
Jack Moffitt's avatar
Jack Moffitt committed
23

Michael Smith's avatar
Michael Smith committed
24 25 26
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
Jack Moffitt's avatar
Jack Moffitt committed
27

Marvin Scholz's avatar
Marvin Scholz committed
28 29 30 31
#include "common/thread/thread.h"
#include "common/avl/avl.h"
#include "common/httpp/httpp.h"
#include "common/net/sock.h"
Jack Moffitt's avatar
Jack Moffitt committed
32 33 34

#include "connection.h"

35
#include "source.h"
Jack Moffitt's avatar
Jack Moffitt committed
36 37 38
#include "global.h"
#include "refbuf.h"
#include "client.h"
39
#include "admin.h"
Jack Moffitt's avatar
Jack Moffitt committed
40
#include "stats.h"
41
#include "xslt.h"
42
#include "util.h"
43 44
#define CATMODULE "stats"
#include "logging.h"
Jack Moffitt's avatar
Jack Moffitt committed
45

46
#ifdef _WIN32
47
#define atoll _atoi64
48
#define vsnprintf _vsnprintf
49
#define snprintf _snprintf
50
#endif
Jack Moffitt's avatar
Jack Moffitt committed
51

52 53 54 55
#define STATS_EVENT_SET     0
#define STATS_EVENT_INC     1
#define STATS_EVENT_DEC     2
#define STATS_EVENT_ADD     3
Karl Heyes's avatar
Karl Heyes committed
56 57 58
#define STATS_EVENT_SUB     4
#define STATS_EVENT_REMOVE  5
#define STATS_EVENT_HIDDEN  6
59

60 61 62 63 64 65 66 67
typedef struct _event_queue_tag
{
    volatile stats_event_t *head;
    volatile stats_event_t **tail;
} event_queue_t;

#define event_queue_init(qp)    { (qp)->head = NULL; (qp)->tail = &(qp)->head; }

Jack Moffitt's avatar
Jack Moffitt committed
68 69
typedef struct _event_listener_tag
{
70 71
    event_queue_t queue;
    mutex_t mutex;
Jack Moffitt's avatar
Jack Moffitt committed
72

73
    struct _event_listener_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
74 75
} event_listener_t;

76
static volatile int _stats_running = 0;
77
static thread_type *_stats_thread_id;
78
static volatile int _stats_threads = 0;
Jack Moffitt's avatar
Jack Moffitt committed
79

80 81
static stats_t _stats;
static mutex_t _stats_mutex;
Jack Moffitt's avatar
Jack Moffitt committed
82

83
static event_queue_t _global_event_queue;
Jack Moffitt's avatar
Jack Moffitt committed
84 85
mutex_t _global_event_mutex;

86
static volatile event_listener_t *_event_listeners;
Jack Moffitt's avatar
Jack Moffitt committed
87 88 89 90 91 92 93


static void *_stats_thread(void *arg);
static int _compare_stats(void *a, void *b, void *arg);
static int _compare_source_stats(void *a, void *b, void *arg);
static int _free_stats(void *key);
static int _free_source_stats(void *key);
94
static void _add_event_to_queue(stats_event_t *event, event_queue_t *queue);
95 96
static stats_node_t *_find_node(avl_tree *tree, const char *name);
static stats_source_t *_find_source(avl_tree *tree, const char *source);
Jack Moffitt's avatar
Jack Moffitt committed
97
static void _free_event(stats_event_t *event);
98
static stats_event_t *_get_event_from_queue(event_queue_t *queue);
99
static void __add_metadata(xmlNodePtr node, const char *tag);
Jack Moffitt's avatar
Jack Moffitt committed
100

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

/* simple helper function for creating an event */
static stats_event_t *build_event (const char *source, const char *name, const char *value)
{
    stats_event_t *event;

    event = (stats_event_t *)calloc(1, sizeof(stats_event_t));
    if (event)
    {
        if (source)
            event->source = (char *)strdup(source);
        if (name)
            event->name = (char *)strdup(name);
        if (value)
            event->value = (char *)strdup(value);
        else
            event->action = STATS_EVENT_REMOVE;
    }
    return event;
}

static void queue_global_event (stats_event_t *event)
{
    thread_mutex_lock(&_global_event_mutex);
125
    _add_event_to_queue (event, &_global_event_queue);
126 127 128
    thread_mutex_unlock(&_global_event_mutex);
}

129
void stats_initialize(void)
Jack Moffitt's avatar
Jack Moffitt committed
130
{
131
    _event_listeners = NULL;
132

133 134 135
    /* set up global struct */
    _stats.global_tree = avl_tree_new(_compare_stats, NULL);
    _stats.source_tree = avl_tree_new(_compare_source_stats, NULL);
Jack Moffitt's avatar
Jack Moffitt committed
136

137 138
    /* set up global mutex */
    thread_mutex_create(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
139

140
    /* set up stats queues */
141
    event_queue_init(&_global_event_queue);
142
    thread_mutex_create(&_global_event_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
143

144 145 146
    /* fire off the stats thread */
    _stats_running = 1;
    _stats_thread_id = thread_create("Stats Thread", _stats_thread, NULL, THREAD_ATTACHED);
Jack Moffitt's avatar
Jack Moffitt committed
147 148
}

149
void stats_shutdown(void)
Jack Moffitt's avatar
Jack Moffitt committed
150
{
151
    int n;
Jack Moffitt's avatar
Jack Moffitt committed
152

153
    if (!_stats_running) /* We can't shutdown if we're not running. */
154 155
        return;

156 157 158
    /* wait for thread to exit */
    _stats_running = 0;
    thread_join(_stats_thread_id);
Jack Moffitt's avatar
Jack Moffitt committed
159

160 161 162 163 164 165 166
    /* wait for other threads to shut down */
    do {
        thread_sleep(300000);
        thread_mutex_lock(&_stats_mutex);
        n = _stats_threads;
        thread_mutex_unlock(&_stats_mutex);
    } while (n > 0);
167
    ICECAST_LOG_INFO("stats thread finished");
168

169
    /* free the queues */
Jack Moffitt's avatar
Jack Moffitt committed
170

171 172
    /* destroy the queue mutexes */
    thread_mutex_destroy(&_global_event_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
173

174 175 176
    thread_mutex_destroy(&_stats_mutex);
    avl_tree_free(_stats.source_tree, _free_source_stats);
    avl_tree_free(_stats.global_tree, _free_stats);
177

178 179 180 181
    while (1)
    {
        stats_event_t *event = _get_event_from_queue (&_global_event_queue);
        if (event == NULL) break;
182 183 184 185
        if(event->source)
            free(event->source);
        if(event->value)
            free(event->value);
186 187
        if(event->name)
            free(event->name);
188 189
        free(event);
    }
Jack Moffitt's avatar
Jack Moffitt committed
190 191
}

192
stats_t *stats_get_stats(void)
Jack Moffitt's avatar
Jack Moffitt committed
193
{
194
    /* lock global stats
195
     
196
     copy stats
Jack Moffitt's avatar
Jack Moffitt committed
197

198
     unlock global stats
Jack Moffitt's avatar
Jack Moffitt committed
199

200
     return copied stats */
Jack Moffitt's avatar
Jack Moffitt committed
201

202
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
203 204
}

205 206
/* simple name=tag stat create/update */
void stats_event(const char *source, const char *name, const char *value)
Jack Moffitt's avatar
Jack Moffitt committed
207
{
208 209
    stats_event_t *event;

210 211
    if (value && xmlCheckUTF8 ((unsigned char *)value) == 0)
    {
212
        ICECAST_LOG_WARN("seen non-UTF8 data, probably incorrect metadata (%s, %s)", name, value);
213 214
        return;
    }
215
    event = build_event(source, name, value);
216
    if (event)
217
        queue_global_event(event);
Jack Moffitt's avatar
Jack Moffitt committed
218 219
}

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240

/* wrapper for stats_event, this takes a charset to convert from */
void stats_event_conv(const char *mount, const char *name, const char *value, const char *charset)
{
    const char *metadata = value;
    xmlBufferPtr conv = xmlBufferCreate ();

    if (charset)
    {
        xmlCharEncodingHandlerPtr handle = xmlFindCharEncodingHandler (charset);

        if (handle)
        {
            xmlBufferPtr raw = xmlBufferCreate ();
            xmlBufferAdd (raw, (const xmlChar *)value, strlen (value));
            if (xmlCharEncInFunc (handle, conv, raw) > 0)
                metadata = (char *)xmlBufferContent (conv);
            xmlBufferFree (raw);
            xmlCharEncCloseFunc (handle);
        }
        else
241
            ICECAST_LOG_WARN("No charset found for \"%s\"", charset);
242 243 244 245 246 247
    }

    stats_event (mount, name, metadata);
    xmlBufferFree (conv);
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
/* 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);
    }
}
264 265 266

/* printf style formatting for stat create/update */
void stats_event_args(const char *source, char *name, char *format, ...)
Jack Moffitt's avatar
Jack Moffitt committed
267
{
268 269
    char buf[1024];
    va_list val;
270 271 272 273
    int ret;

    if (name == NULL)
        return;
274
    va_start(val, format);
275
    ret = vsnprintf(buf, sizeof(buf), format, val);
276
    va_end(val);
Jack Moffitt's avatar
Jack Moffitt committed
277

278 279
    if (ret < 0 || (unsigned int)ret >= sizeof (buf))
    {
280
        ICECAST_LOG_WARN("problem with formatting %s stat %s",
281 282 283
                source==NULL ? "global" : source, name);
        return;
    }
284
    stats_event(source, name, buf);
Jack Moffitt's avatar
Jack Moffitt committed
285 286
}

287
static char *_get_stats(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
288
{
289 290 291
    stats_node_t *stats = NULL;
    stats_source_t *src = NULL;
    char *value = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
292

293
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
294

295 296 297 298 299 300 301 302
    if (source == NULL) {
        stats = _find_node(_stats.global_tree, name);
    } else {
        src = _find_source(_stats.source_tree, source);
        if (src) {
            stats = _find_node(src->stats_tree, name);
        }
    }
Jack Moffitt's avatar
Jack Moffitt committed
303

304
    if (stats) value = (char *)strdup(stats->value);
Jack Moffitt's avatar
Jack Moffitt committed
305

306
    thread_mutex_unlock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
307

308
    return value;
Jack Moffitt's avatar
Jack Moffitt committed
309 310
}

311
char *stats_get_value(const char *source, const char *name)
312
{
313
    return(_get_stats(source, name));
314
}
315 316 317

/* increase the value in the provided stat by 1 */
void stats_event_inc(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
318
{
319
    stats_event_t *event = build_event (source, name, NULL);
320
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
321 322 323 324
    if (event)
    {
        event->action = STATS_EVENT_INC;
        queue_global_event (event);
325
    }
Jack Moffitt's avatar
Jack Moffitt committed
326 327
}

328
void stats_event_add(const char *source, const char *name, unsigned long value)
Jack Moffitt's avatar
Jack Moffitt committed
329
{
330
    stats_event_t *event = build_event (source, name, NULL);
331
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
332 333 334 335 336 337
    if (event)
    {
        event->value = malloc (16);
        snprintf (event->value, 16, "%ld", value);
        event->action = STATS_EVENT_ADD;
        queue_global_event (event);
338
    }
Jack Moffitt's avatar
Jack Moffitt committed
339 340
}

Karl Heyes's avatar
Karl Heyes committed
341 342 343 344 345 346 347 348 349 350 351 352
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, "%ld", value);
        event->action = STATS_EVENT_SUB;
        queue_global_event (event);
    }
}

353 354
/* decrease the value in the provided stat by 1 */
void stats_event_dec(const char *source, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
355
{
356
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
357 358 359 360 361
    stats_event_t *event = build_event (source, name, NULL);
    if (event)
    {
        event->action = STATS_EVENT_DEC;
        queue_global_event (event);
362
    }
Jack Moffitt's avatar
Jack Moffitt committed
363 364 365 366 367
}

/* note: you must call this function only when you have exclusive access
** to the avl_tree
*/
368
static stats_node_t *_find_node(avl_tree *stats_tree, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
369
{
370 371 372 373 374 375
    stats_node_t *stats;
    avl_node *node;
    int cmp;

    /* get the root node */
    node = stats_tree->root->right;
376

377
    while (node) {
378
        stats = (stats_node_t *) node->key;
379 380 381 382 383 384 385 386 387 388 389
        cmp = strcmp(name, stats->name);
        if (cmp < 0) 
            node = node->left;
        else if (cmp > 0)
            node = node->right;
        else
            return stats;
    }
    
    /* didn't find it */
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
390 391 392 393 394
}

/* note: you must call this function only when you have exclusive access
** to the avl_tree
*/
395
static stats_source_t *_find_source(avl_tree *source_tree, const char *source)
Jack Moffitt's avatar
Jack Moffitt committed
396
{
397 398 399 400 401 402 403
    stats_source_t *stats;
    avl_node *node;
    int cmp;

    /* get the root node */
    node = source_tree->root->right;
    while (node) {
404
        stats = (stats_source_t *) node->key;
405 406 407 408 409 410 411 412
        cmp = strcmp(source, stats->source);
        if (cmp < 0)
            node = node->left;
        else if (cmp > 0)
            node = node->right;
        else
            return stats;
    }
Jack Moffitt's avatar
Jack Moffitt committed
413

414 415
    /* didn't find it */
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
416 417 418 419
}

static stats_event_t *_copy_event(stats_event_t *event)
{
420
    stats_event_t *copy = (stats_event_t *)calloc(1, sizeof(stats_event_t));
421 422 423 424
    if (event->source) 
        copy->source = (char *)strdup(event->source);
    else
        copy->source = NULL;
425 426
    if (event->name)
        copy->name = (char *)strdup(event->name);
427 428 429 430
    if (event->value)
        copy->value = (char *)strdup(event->value);
    else
        copy->value = NULL;
431
    copy->hidden = event->hidden;
432
    copy->next = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
433

434
    return copy;
Jack Moffitt's avatar
Jack Moffitt committed
435 436
}

437 438

/* helper to apply specialised changes to a stats node */
439
static void modify_node_event(stats_node_t *node, stats_event_t *event)
440 441 442
{
    char *str;

443 444 445 446 447 448 449 450
    if (event->action == STATS_EVENT_HIDDEN)
    {
        if (event->value)
            node->hidden = 1;
        else
            node->hidden = 0;
        return;
    }
451 452
    if (event->action != STATS_EVENT_SET)
    {
453
        int64_t value = 0;
454 455 456 457 458 459 460 461 462 463 464 465

        switch (event->action)
        {
            case STATS_EVENT_INC:
                value = atoi (node->value)+1;
                break;
            case STATS_EVENT_DEC:
                value = atoi (node->value)-1;
                break;
            case STATS_EVENT_ADD:
                value = atoi (node->value)+atoi (event->value);
                break;
466 467 468
            case STATS_EVENT_SUB:
                value = atoll (node->value) - atoll (event->value);
                break;
469
            default:
470
                ICECAST_LOG_WARN("unhandled event (%d) for %s", event->action, event->source);
471 472 473
                break;
        }
        str = malloc (16);
474
        snprintf (str, 16, "%" PRId64, value);
475 476
        if (event->value == NULL)
            event->value = strdup (str);
477 478 479 480 481
    }
    else
        str = (char *)strdup (event->value);
    free (node->value);
    node->value = str;
482
    if (event->source)
483
        ICECAST_LOG_DEBUG("update \"%s\" %s (%s)", event->source, node->name, node->value);
484
    else
485
        ICECAST_LOG_DEBUG("update global %s (%s)", node->name, node->value);
486 487 488 489 490 491 492
}


static void process_global_event (stats_event_t *event)
{
    stats_node_t *node;

493
    /* ICECAST_LOG_DEBUG("global event %s %s %d", event->name, event->value, event->action); */
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
    if (event->action == STATS_EVENT_REMOVE)
    {
        /* we're deleting */
        node = _find_node(_stats.global_tree, event->name);
        if (node != NULL)
            avl_delete(_stats.global_tree, (void *)node, _free_stats);
        return;
    }
    node = _find_node(_stats.global_tree, event->name);
    if (node)
    {
        modify_node_event (node, event);
    }
    else
    {
        /* add node */
        node = (stats_node_t *)calloc(1, sizeof(stats_node_t));
        node->name = (char *)strdup(event->name);
        node->value = (char *)strdup(event->value);

        avl_insert(_stats.global_tree, (void *)node);
    }
}


static void process_source_event (stats_event_t *event)
{
    stats_source_t *snode = _find_source(_stats.source_tree, event->source);
    if (snode == NULL)
    {
        if (event->action == STATS_EVENT_REMOVE)
            return;
        snode = (stats_source_t *)calloc(1,sizeof(stats_source_t));
        if (snode == NULL)
            return;
529
        ICECAST_LOG_DEBUG("new source stat %s", event->source);
530 531
        snode->source = (char *)strdup(event->source);
        snode->stats_tree = avl_tree_new(_compare_stats, NULL);
532 533 534 535
        if (event->action == STATS_EVENT_HIDDEN)
            snode->hidden = 1;
        else
            snode->hidden = 0;
536

537
        avl_insert(_stats.source_tree, (void *) snode);
538 539 540 541 542 543 544 545 546 547 548
    }
    if (event->name)
    {
        stats_node_t *node = _find_node(snode->stats_tree, event->name);
        if (node == NULL)
        {
            if (event->action == STATS_EVENT_REMOVE)
                return;
            /* adding node */
            if (event->value)
            {
549
                ICECAST_LOG_DEBUG("new node %s (%s)", event->name, event->value);
550 551 552
                node = (stats_node_t *)calloc(1,sizeof(stats_node_t));
                node->name = (char *)strdup(event->name);
                node->value = (char *)strdup(event->value);
553
                node->hidden = snode->hidden;
554 555 556 557 558 559 560

                avl_insert(snode->stats_tree, (void *)node);
            }
            return;
        }
        if (event->action == STATS_EVENT_REMOVE)
        {
561
            ICECAST_LOG_DEBUG("delete node %s", event->name);
562 563 564 565 566 567
            avl_delete(snode->stats_tree, (void *)node, _free_stats);
            return;
        }
        modify_node_event (node, event);
        return;
    }
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
    if (event->action == STATS_EVENT_HIDDEN)
    {
        avl_node *node = avl_get_first (snode->stats_tree);

        if (event->value)
            snode->hidden = 1;
        else
            snode->hidden = 0;
        while (node)
        {
            stats_node_t *stats = (stats_node_t*)node->key;
            stats->hidden = snode->hidden;
            node = avl_get_next (node);
        }
        return;
    }
584 585
    if (event->action == STATS_EVENT_REMOVE)
    {
586
        ICECAST_LOG_DEBUG("delete source node %s", event->source);
587 588 589 590
        avl_delete(_stats.source_tree, (void *)snode, _free_source_stats);
    }
}

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
/* NOTE: implicit %z is added to format string. */
static inline void __format_time(char * buffer, size_t len, const char * format) {
    time_t now = time(NULL);
    struct tm local;
    char tzbuffer[32];
    char timebuffer[128];
#ifdef _WIN32
    struct tm *thetime;
    int time_days, time_hours, time_tz;
    int tempnum1, tempnum2;
    char sign;
#endif

    localtime_r (&now, &local);
#ifndef _WIN32
    strftime (tzbuffer, sizeof(tzbuffer), "%z", &local);
#else
    thetime = gmtime (&now);
    time_days = local.tm_yday - thetime->tm_yday;

    if (time_days < -1) {
        tempnum1 = 24;
    } else {
        tempnum1 = 1;
    }

    if (tempnum1 < time_days) {
        tempnum2 = -24;
    } else {
        tempnum2 = time_days*24;
    }

    time_hours = (tempnum2 + local.tm_hour - thetime->tm_hour);
    time_tz = time_hours * 60 + local.tm_min - thetime->tm_min;

    if (time_tz < 0) {
        sign = '-';
        time_tz = -time_tz;
    } else {
        sign = '+';
    }

    snprintf(tzbuffer, sizeof(tzbuffer), "%c%.2d%.2d", sign, time_tz / 60, time_tz % 60);
#endif
    strftime (timebuffer, sizeof(timebuffer), format, &local);

    snprintf(buffer, len, "%s%s", timebuffer, tzbuffer);
}
639

Karl Heyes's avatar
Karl Heyes committed
640 641 642 643
void stats_event_time (const char *mount, const char *name)
{
    char buffer[100];

644
    __format_time(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S ");
Karl Heyes's avatar
Karl Heyes committed
645 646 647 648
    stats_event (mount, name, buffer);
}


649 650 651 652
void stats_event_time_iso8601 (const char *mount, const char *name)
{
    char buffer[100];

653
    __format_time(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S");
654 655 656 657
    stats_event (mount, name, buffer);
}


Karl Heyes's avatar
Karl Heyes committed
658 659
void stats_global (ice_config_t *config)
{
660
    stats_event (NULL, "server_id", config->server_id);
Karl Heyes's avatar
Karl Heyes committed
661 662 663 664 665 666
    stats_event (NULL, "host", config->hostname);
    stats_event (NULL, "location", config->location);
    stats_event (NULL, "admin", config->admin);
}


Jack Moffitt's avatar
Jack Moffitt committed
667 668
static void *_stats_thread(void *arg)
{
669 670 671 672
    stats_event_t *event;
    stats_event_t *copy;
    event_listener_t *listener;

Karl Heyes's avatar
Karl Heyes committed
673
    stats_event_time (NULL, "server_start");
674
    stats_event_time_iso8601 (NULL, "server_start_iso8601");
675 676 677 678 679 680

    /* global currently active stats */
    stats_event (NULL, "clients", "0");
    stats_event (NULL, "connections", "0");
    stats_event (NULL, "sources", "0");
    stats_event (NULL, "stats", "0");
Karl Heyes's avatar
Karl Heyes committed
681
    stats_event (NULL, "listeners", "0");
682 683 684 685 686 687 688

    /* global accumulating stats */
    stats_event (NULL, "client_connections", "0");
    stats_event (NULL, "source_client_connections", "0");
    stats_event (NULL, "source_relay_connections", "0");
    stats_event (NULL, "source_total_connections", "0");
    stats_event (NULL, "stats_connections", "0");
689
    stats_event (NULL, "listener_connections", "0");
690

691
    ICECAST_LOG_INFO("stats thread started");
692
    while (_stats_running) {
693
        thread_mutex_lock(&_global_event_mutex);
694
        if (_global_event_queue.head != NULL) {
695
            /* grab the next event from the queue */
696
            event = _get_event_from_queue (&_global_event_queue);
697 698
            thread_mutex_unlock(&_global_event_mutex);

699 700
            if (event == NULL)
                continue;
701 702 703
            event->next = NULL;

            thread_mutex_lock(&_stats_mutex);
704 705 706 707 708 709

            /* check if we are dealing with a global or source event */
            if (event->source == NULL)
                process_global_event (event);
            else
                process_source_event (event);
710 711 712
            
            /* now we have an event that's been processed into the running stats */
            /* this event should get copied to event listeners' queues */
713
            listener = (event_listener_t *)_event_listeners;
714 715
            while (listener) {
                copy = _copy_event(event);
716 717 718
                thread_mutex_lock (&listener->mutex);
                _add_event_to_queue (copy, &listener->queue);
                thread_mutex_unlock (&listener->mutex);
719 720 721 722 723 724 725 726

                listener = listener->next;
            }

            /* now we need to destroy the event */
            _free_event(event);

            thread_mutex_unlock(&_stats_mutex);
727
            continue;
728
        }
729 730 731 732
        else
        {
            thread_mutex_unlock(&_global_event_mutex);
        }
733

734
        thread_sleep(300000);
735 736 737
    }

    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
738 739
}

740
/* you must have the _stats_mutex locked here */
741
static void _unregister_listener(event_listener_t *listener)
742 743 744 745 746
{
    event_listener_t **prev = (event_listener_t **)&_event_listeners,
                     *current = *prev;
    while (current)
    {
747
        if (current == listener)
748 749 750 751 752 753 754 755 756 757
        {
            *prev = current->next;
            break;
        }
        prev = &current->next;
        current = *prev;
    }
}


Jack Moffitt's avatar
Jack Moffitt committed
758 759
static stats_event_t *_make_event_from_node(stats_node_t *node, char *source)
{
760 761 762 763 764 765 766 767
    stats_event_t *event = (stats_event_t *)malloc(sizeof(stats_event_t));
    
    if (source != NULL)
        event->source = (char *)strdup(source);
    else
        event->source = NULL;
    event->name = (char *)strdup(node->name);
    event->value = (char *)strdup(node->value);
768
    event->hidden = node->hidden;
769
    event->action = STATS_EVENT_SET;
770
    event->next = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
771

772
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
773 774 775
}


776 777 778 779
static void _add_event_to_queue(stats_event_t *event, event_queue_t *queue)
{
    *queue->tail = event;
    queue->tail = (volatile stats_event_t **)&event->next;
Jack Moffitt's avatar
Jack Moffitt committed
780 781 782
}


783 784 785
static stats_event_t *_get_event_from_queue (event_queue_t *queue)
{
    stats_event_t *event = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
786

787 788 789 790 791 792 793
    if (queue && queue->head)
    {
        event = (stats_event_t *)queue->head;
        queue->head = event->next;
        if (queue->head == NULL)
            queue->tail = &queue->head;
    }
Jack Moffitt's avatar
Jack Moffitt committed
794

795
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
796 797
}

798
static int _send_event_to_client(stats_event_t *event, client_t *client)
Jack Moffitt's avatar
Jack Moffitt committed
799
{
800
    int len;
801
    char buf [200];
Jack Moffitt's avatar
Jack Moffitt committed
802

803
    /* send data to the client!!!! */
804
    len = snprintf (buf, sizeof (buf), "EVENT %s %s %s\n",
805 806 807
            (event->source != NULL) ? event->source : "global",
            event->name ? event->name : "null",
            event->value ? event->value : "null");
808
    if (len > 0 && len < (int)sizeof (buf))
809 810 811 812 813 814
    {
        client_send_bytes (client, buf, len);
        if (client->con->error)
            return -1;
    }
    return 0;
Jack Moffitt's avatar
Jack Moffitt committed
815 816
}

817 818

static xmlNodePtr _dump_stats_to_doc (xmlNodePtr root, const char *show_mount, int hidden)
Jack Moffitt's avatar
Jack Moffitt committed
819
{
820 821
    avl_node *avlnode;
    xmlNodePtr ret = NULL;
822 823

    thread_mutex_lock(&_stats_mutex);
824 825 826 827 828 829 830 831 832 833 834 835 836 837
    /* general stats first */
    avlnode = avl_get_first(_stats.global_tree);
    while (avlnode)
    {
        stats_node_t *stat = avlnode->key;
        if (stat->hidden <=  hidden)
            xmlNewTextChild (root, NULL, XMLSTR(stat->name), XMLSTR(stat->value));
        avlnode = avl_get_next (avlnode);
    }
    /* now per mount stats */
    avlnode = avl_get_first(_stats.source_tree);
    while (avlnode)
    {
        stats_source_t *source = (stats_source_t *)avlnode->key;
838

839 840 841
        if (source->hidden <= hidden &&
                (show_mount == NULL || strcmp (show_mount, source->source) == 0))
        {
842 843 844 845
            xmlNodePtr metadata;
            source_t *source_real;
            int i;

846 847
            avl_node *avlnode2 = avl_get_first (source->stats_tree);
            xmlNodePtr xmlnode = xmlNewTextChild (root, NULL, XMLSTR("source"), NULL);
848

849 850 851 852 853 854 855 856 857
            xmlSetProp (xmlnode, XMLSTR("mount"), XMLSTR(source->source));
            if (ret == NULL)
                ret = xmlnode;
            while (avlnode2)
            {
                stats_node_t *stat = avlnode2->key;
                xmlNewTextChild (xmlnode, NULL, XMLSTR(stat->name), XMLSTR(stat->value));
                avlnode2 = avl_get_next (avlnode2);
            }
858 859 860 861 862 863 864 865


            metadata = xmlNewTextChild(xmlnode, NULL, XMLSTR("metadata"), NULL);
            avl_tree_rlock(global.source_tree);
            source_real = source_find_mount_raw(source->source);
            for (i = 0; i < source_real->format->vc.comments; i++)
                __add_metadata(metadata, source_real->format->vc.user_comments[i]);
            avl_tree_unlock(global.source_tree);
866
        }
867
        avlnode = avl_get_next (avlnode);
868 869
    }
    thread_mutex_unlock(&_stats_mutex);
870
    return ret;
Jack Moffitt's avatar
Jack Moffitt committed
871 872
}

873

874 875 876 877 878
/* factoring out code for stats loops
** this function copies all stats to queue, and registers 
** the queue for all new events atomically.
** note: mutex must already be created!
*/
879
static void _register_listener (event_listener_t *listener)
Jack Moffitt's avatar
Jack Moffitt committed
880
{
881 882 883 884
    avl_node *node;
    avl_node *node2;
    stats_event_t *event;
    stats_source_t *source;
Jack Moffitt's avatar
Jack Moffitt committed
885

886
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
887

888
    /* first we fill our queue with the current stats */
889

890 891 892
    /* start with the global stats */
    node = avl_get_first(_stats.global_tree);
    while (node) {
893 894
        event = _make_event_from_node((stats_node_t *) node->key, NULL);
        _add_event_to_queue(event, &listener->queue);
Jack Moffitt's avatar
Jack Moffitt committed
895

896 897
        node = avl_get_next(node);
    }
Jack Moffitt's avatar
Jack Moffitt committed
898

899 900 901 902 903 904 905
    /* now the stats for each source */
    node = avl_get_first(_stats.source_tree);
    while (node) {
        source = (stats_source_t *)node->key;
        node2 = avl_get_first(source->stats_tree);
        while (node2) {
            event = _make_event_from_node((stats_node_t *)node2->key, source->source);
906
            _add_event_to_queue (event, &listener->queue);
907 908 909 910 911 912

            node2 = avl_get_next(node2);
        }
        
        node = avl_get_next(node);
    }
Jack Moffitt's avatar
Jack Moffitt committed
913

914
    /* now we register to receive future event notices */
915 916
    listener->next = (event_listener_t *)_event_listeners;
    _event_listeners = listener;
Jack Moffitt's avatar
Jack Moffitt committed
917

918
    thread_mutex_unlock(&_stats_mutex);
919 920 921 922
}

void *stats_connection(void *arg)
{
923
    client_t *client = (client_t *)arg;
924
    stats_event_t *event;
925
    event_listener_t listener;
926

927
    ICECAST_LOG_INFO("stats client starting");
928

929
    event_queue_init (&listener.queue);
930 931 932
    /* increment the thread count */
    thread_mutex_lock(&_stats_mutex);
    _stats_threads++;
933
    stats_event_args (NULL, "stats", "%d", _stats_threads);
934 935
    thread_mutex_unlock(&_stats_mutex);

936
    thread_mutex_create (&(listener.mutex));
937

938
    _register_listener (&listener);
939 940

    while (_stats_running) {
941 942 943
        thread_mutex_lock (&listener.mutex);
        event = _get_event_from_queue (&listener.queue);
        thread_mutex_unlock (&listener.mutex);
944
        if (event != NULL) {
945
            if (_send_event_to_client(event, client) < 0) {
946 947 948 949 950 951
                _free_event(event);
                break;
            }
            _free_event(event);
            continue;
        }
952
        thread_sleep (500000);
953 954 955
    }

    thread_mutex_lock(&_stats_mutex);
956
    _unregister_listener (&listener);
957
    _stats_threads--;
958
    stats_event_args (NULL, "stats", "%d", _stats_threads);
959 960
    thread_mutex_unlock(&_stats_mutex);

961
    thread_mutex_destroy (&listener.mutex);
962
    client_destroy (client);
963
    ICECAST_LOG_INFO("stats client finished");
964

965
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
966 967
}

968 969 970 971 972 973 974 975 976 977 978 979 980

void stats_callback (client_t *client, void *notused)
{
    if (client->con->error)
    {
        client_destroy (client);
        return;
    }
    client_set_queue (client, NULL);
    thread_create("Stats Connection", stats_connection, (void *)client, THREAD_DETACHED);
}


Jack Moffitt's avatar
Jack Moffitt committed
981
typedef struct _source_xml_tag {
982 983
    char *mount;
    xmlNodePtr node;
Jack Moffitt's avatar
Jack Moffitt committed
984

985
    struct _source_xml_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
986 987 988
} source_xml_t;


989
void stats_transform_xslt(client_t *client, const char *uri)
990 991
{
    xmlDocPtr doc;
992 993
    char *xslpath = util_get_path_from_normalised_uri(uri);
    const char *mount = httpp_get_query_param(client->parser, "mount");
994

995
    doc = stats_get_xml(0, mount, client->mode);
996

997
    xslt_transform(doc, xslpath, client);
998 999

    xmlFreeDoc(doc);
1000
    free(xslpath);
1001 1002
}

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
static void __add_metadata(xmlNodePtr node, const char *tag) {
    const char *value = strstr(tag, "=");
    char *name = NULL;
    size_t namelen = value - tag + 1;
    size_t i;

    if (!value)
        return;

    name = malloc(namelen);
    if (!name)
        return;

    for (i = 0; i < (namelen - 1); i++)
        name[i] = tolower(tag[i]);

    name[namelen-1] = 0;

    xmlNewTextChild(node, NULL, XMLSTR(name), XMLSTR(value+1));

    free(name);
}

1026
xmlDocPtr stats_get_xml(int show_hidden, const char *show_mount, operation_mode mode)
Jack Moffitt's avatar
Jack Moffitt committed
1027
{
1028
    xmlDocPtr doc;
1029
    xmlNodePtr node;
1030
    source_t * source;
1031

1032 1033
    doc = xmlNewDoc (XMLSTR("1.0"));
    node = xmlNewDocNode (doc, NULL, XMLSTR("icestats"), NULL);
1034 1035
    xmlDocSetRootElement(doc, node);

1036
    node = _dump_stats_to_doc (node, show_mount, show_hidden);
1037

1038 1039 1040
    if (show_mount && node) {
        avl_tree_rlock(global.source_tree);
        source = source_find_mount_raw(show_mount);
1041
        admin_add_listeners_to_mount(source, node, mode);
1042 1043 1044
        avl_tree_unlock(global.source_tree);
    }

1045
    return doc;
Jack Moffitt's avatar
Jack Moffitt committed
1046 1047
}

1048

Jack Moffitt's avatar
Jack Moffitt committed
1049 1050
static int _compare_stats(void *arg, void *a, void *b)
{
1051 1052
    stats_node_t *nodea = (stats_node_t *)a;
    stats_node_t *nodeb = (stats_node_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1053

1054
    return strcmp(nodea->name, nodeb->name);
Jack Moffitt's avatar
Jack Moffitt committed
1055 1056 1057 1058
}

static int _compare_source_stats(void *arg, void *a, void *b)
{
1059 1060
    stats_source_t *nodea = (stats_source_t *)a;
    stats_source_t *nodeb = (stats_source_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1061

1062
    return strcmp(nodea->source, nodeb->source);
Jack Moffitt's avatar
Jack Moffitt committed
1063 1064 1065 1066
}

static int _free_stats(void *key)
{
1067 1068 1069 1070 1071 1072
    stats_node_t *node = (stats_node_t *)key;
    free(node->value);
    free(node->name);
    free(node);
    
    return 1;
Jack Moffitt's avatar
Jack Moffitt committed
1073 1074 1075 1076
}

static int _free_source_stats(void *key)
{
1077 1078 1079
    stats_source_t *node = (stats_source_t *)key;
    avl_tree_free(node->stats_tree, _free_stats);
    free(node->source);
1080
    free(node);
Jack Moffitt's avatar
Jack Moffitt committed
1081

1082
    return 1;
Jack Moffitt's avatar
Jack Moffitt committed
1083 1084 1085 1086
}

static void _free_event(stats_event_t *event)
{
1087 1088 1089 1090
    if (event->source) free(event->source);
    if (event->name) free(event->name);
    if (event->value) free(event->value);
    free(event);
Jack Moffitt's avatar
Jack Moffitt committed
1091
}
1092 1093


1094
refbuf_t *stats_get_streams (void)
1095
{
1096
#define STREAMLIST_BLKSIZE  4096
1097
    avl_node *node;
1098
    unsigned int remaining = STREAMLIST_BLKSIZE;
1099 1100
    refbuf_t *start = refbuf_new (remaining), *cur = start;
    char *buffer = cur->data;
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111

    /* now the stats for each source */
    thread_mutex_lock (&_stats_mutex);
    node = avl_get_first(_stats.source_tree);
    while (node)
    {
        int ret;
        stats_source_t *source = (stats_source_t *)node->key;

        if (source->hidden == 0)
        {
1112
            if (remaining <= strlen (source->source) + 3)
1113
            {
1114 1115 1116 1117 1118
                cur->len = STREAMLIST_BLKSIZE - remaining;
                cur->next = refbuf_new (STREAMLIST_BLKSIZE);
                remaining = STREAMLIST_BLKSIZE;
                cur = cur->next;
                buffer = cur->data;
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
            }
            ret = snprintf (buffer, remaining, "%s\r\n", source->source);
            if (ret > 0)
            {
                buffer += ret;
                remaining -= ret;
            }
        }
        node = avl_get_next(node);
    }
1129
    thread_mutex_unlock(&_stats_mutex);
1130 1131
    cur->len = STREAMLIST_BLKSIZE - remaining;
    return start;
1132 1133
}

1134 1135


1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
/* This removes any source stats from virtual mountpoints, ie mountpoints
 * where no source_t exists. This function requires the global sources lock
 * to be held before calling.
 */
void stats_clear_virtual_mounts (void)
{
    avl_node *snode;

    thread_mutex_lock (&_stats_mutex);
    snode = avl_get_first(_stats.source_tree);
    while (snode)
    {
        stats_source_t *src = (stats_source_t *)snode->key;
        source_t *source = source_find_mount_raw (src->source);

        if (source == NULL)
        {
            /* no source_t is reserved so remove them now */
            snode = avl_get_next (snode);
1155
            ICECAST_LOG_DEBUG("releasing %s stats", src->source);
1156 1157 1158 1159 1160 1161 1162 1163 1164
            avl_delete (_stats.source_tree, src, _free_source_stats);
            continue;
        }

        snode = avl_get_next (snode);
    }
    thread_mutex_unlock (&_stats_mutex);
}