stats.c 29.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 22
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

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

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

#include "connection.h"

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

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

51 52 53 54
#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
55 56 57
#define STATS_EVENT_SUB     4
#define STATS_EVENT_REMOVE  5
#define STATS_EVENT_HIDDEN  6
58

59 60 61 62 63 64 65 66
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
67 68
typedef struct _event_listener_tag
{
69 70
    event_queue_t queue;
    mutex_t mutex;
Jack Moffitt's avatar
Jack Moffitt committed
71

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

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

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

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

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


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);
93
static void _add_event_to_queue(stats_event_t *event, event_queue_t *queue);
94 95
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
96
static void _free_event(stats_event_t *event);
97
static stats_event_t *_get_event_from_queue (event_queue_t *queue);
Jack Moffitt's avatar
Jack Moffitt committed
98

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

/* 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);
123
    _add_event_to_queue (event, &_global_event_queue);
124 125 126
    thread_mutex_unlock(&_global_event_mutex);
}

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

131 132 133
    /* 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
134

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

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

142 143 144
    /* 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
145 146
}

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

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

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

158 159 160 161 162 163 164
    /* 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);
165
    ICECAST_LOG_INFO("stats thread finished");
166

167
    /* free the queues */
Jack Moffitt's avatar
Jack Moffitt committed
168

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

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

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

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

196
     unlock global stats
Jack Moffitt's avatar
Jack Moffitt committed
197

198
     return copied stats */
Jack Moffitt's avatar
Jack Moffitt committed
199

200
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
201 202
}

203 204
/* 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
205
{
206 207
    stats_event_t *event;

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

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

/* 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
239
            ICECAST_LOG_WARN("No charset found for \"%s\"", charset);
240 241 242 243 244 245
    }

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

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

/* 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
265
{
266 267
    char buf[1024];
    va_list val;
268 269 270 271
    int ret;

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

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

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

291
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
292

293 294 295 296 297 298 299 300
    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
301

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

304
    thread_mutex_unlock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
305

306
    return value;
Jack Moffitt's avatar
Jack Moffitt committed
307 308
}

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

/* 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
316
{
317
    stats_event_t *event = build_event (source, name, NULL);
318
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
319 320 321 322
    if (event)
    {
        event->action = STATS_EVENT_INC;
        queue_global_event (event);
323
    }
Jack Moffitt's avatar
Jack Moffitt committed
324 325
}

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

Karl Heyes's avatar
Karl Heyes committed
339 340 341 342 343 344 345 346 347 348 349 350
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);
    }
}

351 352
/* 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
353
{
354
    /* ICECAST_LOG_DEBUG("%s on %s", name, source==NULL?"global":source); */
355 356 357 358 359
    stats_event_t *event = build_event (source, name, NULL);
    if (event)
    {
        event->action = STATS_EVENT_DEC;
        queue_global_event (event);
360
    }
Jack Moffitt's avatar
Jack Moffitt committed
361 362 363 364 365
}

/* note: you must call this function only when you have exclusive access
** to the avl_tree
*/
366
static stats_node_t *_find_node(avl_tree *stats_tree, const char *name)
Jack Moffitt's avatar
Jack Moffitt committed
367
{
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
    stats_node_t *stats;
    avl_node *node;
    int cmp;

    /* get the root node */
    node = stats_tree->root->right;
    
    while (node) {
        stats = (stats_node_t *)node->key;
        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
388 389 390 391 392
}

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

    /* get the root node */
    node = source_tree->root->right;
    while (node) {
        stats = (stats_source_t *)node->key;
        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
411

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

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

432
    return copy;
Jack Moffitt's avatar
Jack Moffitt committed
433 434
}

435 436 437 438 439 440

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

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

        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;
464 465 466
            case STATS_EVENT_SUB:
                value = atoll (node->value) - atoll (event->value);
                break;
467
            default:
468
                ICECAST_LOG_WARN("unhandled event (%d) for %s", event->action, event->source);
469 470 471
                break;
        }
        str = malloc (16);
472
        snprintf (str, 16, "%" PRId64, value);
473 474
        if (event->value == NULL)
            event->value = strdup (str);
475 476 477 478 479
    }
    else
        str = (char *)strdup (event->value);
    free (node->value);
    node->value = str;
480
    if (event->source)
481
        ICECAST_LOG_DEBUG("update \"%s\" %s (%s)", event->source, node->name, node->value);
482
    else
483
        ICECAST_LOG_DEBUG("update global %s (%s)", node->name, node->value);
484 485 486 487 488 489 490
}


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

491
    /* ICECAST_LOG_DEBUG("global event %s %s %d", event->name, event->value, event->action); */
492 493 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
    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;
527
        ICECAST_LOG_DEBUG("new source stat %s", event->source);
528 529
        snode->source = (char *)strdup(event->source);
        snode->stats_tree = avl_tree_new(_compare_stats, NULL);
530 531 532 533
        if (event->action == STATS_EVENT_HIDDEN)
            snode->hidden = 1;
        else
            snode->hidden = 0;
534 535 536 537 538 539 540 541 542 543 544 545 546

        avl_insert(_stats.source_tree, (void *)snode);
    }
    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)
            {
547
                ICECAST_LOG_DEBUG("new node %s (%s)", event->name, event->value);
548 549 550
                node = (stats_node_t *)calloc(1,sizeof(stats_node_t));
                node->name = (char *)strdup(event->name);
                node->value = (char *)strdup(event->value);
551
                node->hidden = snode->hidden;
552 553 554 555 556 557 558

                avl_insert(snode->stats_tree, (void *)node);
            }
            return;
        }
        if (event->action == STATS_EVENT_REMOVE)
        {
559
            ICECAST_LOG_DEBUG("delete node %s", event->name);
560 561 562 563 564 565
            avl_delete(snode->stats_tree, (void *)node, _free_stats);
            return;
        }
        modify_node_event (node, event);
        return;
    }
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
    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;
    }
582 583
    if (event->action == STATS_EVENT_REMOVE)
    {
584
        ICECAST_LOG_DEBUG("delete source node %s", event->source);
585 586 587 588
        avl_delete(_stats.source_tree, (void *)snode, _free_source_stats);
    }
}

589 590 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
/* 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);
}
637

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

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


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

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


Karl Heyes's avatar
Karl Heyes committed
656 657
void stats_global (ice_config_t *config)
{
658
    stats_event (NULL, "server_id", config->server_id);
Karl Heyes's avatar
Karl Heyes committed
659 660 661 662 663 664
    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
665 666
static void *_stats_thread(void *arg)
{
667 668 669 670
    stats_event_t *event;
    stats_event_t *copy;
    event_listener_t *listener;

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

    /* 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
679
    stats_event (NULL, "listeners", "0");
680 681 682 683 684 685 686

    /* 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");
687
    stats_event (NULL, "listener_connections", "0");
688

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

697 698
            if (event == NULL)
                continue;
699 700 701
            event->next = NULL;

            thread_mutex_lock(&_stats_mutex);
702 703 704 705 706 707

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

                listener = listener->next;
            }

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

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

732
        thread_sleep(300000);
733 734 735
    }

    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
736 737
}

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


Jack Moffitt's avatar
Jack Moffitt committed
756 757
static stats_event_t *_make_event_from_node(stats_node_t *node, char *source)
{
758 759 760 761 762 763 764 765
    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);
766
    event->hidden = node->hidden;
767
    event->action = STATS_EVENT_SET;
768
    event->next = NULL;
Jack Moffitt's avatar
Jack Moffitt committed
769

770
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
771 772 773
}


774 775 776 777
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
778 779 780
}


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

785 786 787 788 789 790 791
    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
792

793
    return event;
Jack Moffitt's avatar
Jack Moffitt committed
794 795
}

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

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

815 816

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

    thread_mutex_lock(&_stats_mutex);
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
    /* 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;
        if (source->hidden <= hidden &&
                (show_mount == NULL || strcmp (show_mount, source->source) == 0))
        {
            avl_node *avlnode2 = avl_get_first (source->stats_tree);
            xmlNodePtr xmlnode = xmlNewTextChild (root, NULL, XMLSTR("source"), NULL);
841

842 843 844 845 846 847 848 849 850
            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);
            }
851
        }
852
        avlnode = avl_get_next (avlnode);
853 854
    }
    thread_mutex_unlock(&_stats_mutex);
855
    return ret;
Jack Moffitt's avatar
Jack Moffitt committed
856 857
}

858

859 860 861 862 863
/* 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!
*/
864
static void _register_listener (event_listener_t *listener)
Jack Moffitt's avatar
Jack Moffitt committed
865
{
866 867 868 869
    avl_node *node;
    avl_node *node2;
    stats_event_t *event;
    stats_source_t *source;
Jack Moffitt's avatar
Jack Moffitt committed
870

871
    thread_mutex_lock(&_stats_mutex);
Jack Moffitt's avatar
Jack Moffitt committed
872

873 874 875 876 877 878
    /* first we fill our queue with the current stats */
    
    /* start with the global stats */
    node = avl_get_first(_stats.global_tree);
    while (node) {
        event = _make_event_from_node((stats_node_t *)node->key, NULL);
879
        _add_event_to_queue (event, &listener->queue);
Jack Moffitt's avatar
Jack Moffitt committed
880

881 882
        node = avl_get_next(node);
    }
Jack Moffitt's avatar
Jack Moffitt committed
883

884 885 886 887 888 889 890
    /* 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);
891
            _add_event_to_queue (event, &listener->queue);
892 893 894 895 896 897

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

899
    /* now we register to receive future event notices */
900 901
    listener->next = (event_listener_t *)_event_listeners;
    _event_listeners = listener;
Jack Moffitt's avatar
Jack Moffitt committed
902

903
    thread_mutex_unlock(&_stats_mutex);
904 905 906 907
}

void *stats_connection(void *arg)
{
908
    client_t *client = (client_t *)arg;
909
    stats_event_t *event;
910
    event_listener_t listener;
911

912
    ICECAST_LOG_INFO("stats client starting");
913

914
    event_queue_init (&listener.queue);
915 916 917
    /* increment the thread count */
    thread_mutex_lock(&_stats_mutex);
    _stats_threads++;
918
    stats_event_args (NULL, "stats", "%d", _stats_threads);
919 920
    thread_mutex_unlock(&_stats_mutex);

921
    thread_mutex_create (&(listener.mutex));
922

923
    _register_listener (&listener);
924 925

    while (_stats_running) {
926 927 928
        thread_mutex_lock (&listener.mutex);
        event = _get_event_from_queue (&listener.queue);
        thread_mutex_unlock (&listener.mutex);
929
        if (event != NULL) {
930
            if (_send_event_to_client(event, client) < 0) {
931 932 933 934 935 936
                _free_event(event);
                break;
            }
            _free_event(event);
            continue;
        }
937
        thread_sleep (500000);
938 939 940
    }

    thread_mutex_lock(&_stats_mutex);
941
    _unregister_listener (&listener);
942
    _stats_threads--;
943
    stats_event_args (NULL, "stats", "%d", _stats_threads);
944 945
    thread_mutex_unlock(&_stats_mutex);

946
    thread_mutex_destroy (&listener.mutex);
947
    client_destroy (client);
948
    ICECAST_LOG_INFO("stats client finished");
949

950
    return NULL;
Jack Moffitt's avatar
Jack Moffitt committed
951 952
}

953 954 955 956 957 958 959 960 961 962 963 964 965

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
966
typedef struct _source_xml_tag {
967 968
    char *mount;
    xmlNodePtr node;
Jack Moffitt's avatar
Jack Moffitt committed
969

970
    struct _source_xml_tag *next;
Jack Moffitt's avatar
Jack Moffitt committed
971 972 973
} source_xml_t;


974
void stats_transform_xslt(client_t *client, const char *uri)
975 976
{
    xmlDocPtr doc;
977
    char *xslpath = util_get_path_from_normalised_uri (uri);
978
    const char *mount = httpp_get_query_param (client->parser, "mount");
979

980
    doc = stats_get_xml (0, mount);
981

982
    xslt_transform(doc, xslpath, client);
983 984

    xmlFreeDoc(doc);
985
    free (xslpath);
986 987
}

988
xmlDocPtr stats_get_xml(int show_hidden, const char *show_mount)
Jack Moffitt's avatar
Jack Moffitt committed
989
{
990
    xmlDocPtr doc;
991
    xmlNodePtr node;
992
    source_t * source;
993

994 995
    doc = xmlNewDoc (XMLSTR("1.0"));
    node = xmlNewDocNode (doc, NULL, XMLSTR("icestats"), NULL);
996 997
    xmlDocSetRootElement(doc, node);

998
    node = _dump_stats_to_doc (node, show_mount, show_hidden);
999

1000 1001 1002 1003 1004 1005 1006
    if (show_mount && node) {
        avl_tree_rlock(global.source_tree);
        source = source_find_mount_raw(show_mount);
        admin_add_listeners_to_mount(source, node);
        avl_tree_unlock(global.source_tree);
    }

1007
    return doc;
Jack Moffitt's avatar
Jack Moffitt committed
1008 1009
}

1010

Jack Moffitt's avatar
Jack Moffitt committed
1011 1012
static int _compare_stats(void *arg, void *a, void *b)
{
1013 1014
    stats_node_t *nodea = (stats_node_t *)a;
    stats_node_t *nodeb = (stats_node_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1015

1016
    return strcmp(nodea->name, nodeb->name);
Jack Moffitt's avatar
Jack Moffitt committed
1017 1018 1019 1020
}

static int _compare_source_stats(void *arg, void *a, void *b)
{
1021 1022
    stats_source_t *nodea = (stats_source_t *)a;
    stats_source_t *nodeb = (stats_source_t *)b;
Jack Moffitt's avatar
Jack Moffitt committed
1023

1024
    return strcmp(nodea->source, nodeb->source);
Jack Moffitt's avatar
Jack Moffitt committed
1025 1026 1027 1028
}

static int _free_stats(void *key)
{
1029 1030 1031 1032 1033 1034
    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
1035 1036 1037 1038
}

static int _free_source_stats(void *key)
{
1039 1040 1041
    stats_source_t *node = (stats_source_t *)key;
    avl_tree_free(node->stats_tree, _free_stats);
    free(node->source);
1042
    free(node);
Jack Moffitt's avatar
Jack Moffitt committed
1043

1044
    return 1;
Jack Moffitt's avatar
Jack Moffitt committed
1045 1046 1047 1048
}

static void _free_event(stats_event_t *event)
{
1049 1050 1051 1052
    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
1053
}
1054 1055


1056
refbuf_t *stats_get_streams (void)
1057
{
1058
#define STREAMLIST_BLKSIZE  4096
1059
    avl_node *node;
1060
    unsigned int remaining = STREAMLIST_BLKSIZE;
1061 1062
    refbuf_t *start = refbuf_new (remaining), *cur = start;
    char *buffer = cur->data;
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073

    /* now the stats for each source */
    thread_mutex_lock (&_stats_mutex);
    node = avl_get_first(_stats.