aniani/icecast-common
1
0
Fork 0
mirror of https://gitlab.xiph.org/xiph/icecast-common.git synced 2024-06-23 06:25:25 +00:00
Code

Merge branch 'feature-logcore' into libigloo

Browse Source
This commit is contained in:
Philipp Schafft 2019-09-18 09:09:45 +00:00
commit 177da5b786
4 changed files with 589 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -26,6 +26,7 @@ pkginclude_HEADERS = \
include/igloo/filter.h \
include/igloo/objecthandler.h \
include/igloo/logmsg.h \
include/igloo/logcore.h \
include/igloo/buffer.h \
include/igloo/list.h \
include/igloo/error.h \
@ -41,6 +42,7 @@ libigloo_la_SOURCES = \
src/filter.c \
src/objecthandler.c \
src/logmsg.c \
src/logcore.c \
src/buffer.c \
src/list.c \
src/error.c \

172
include/igloo/logcore.h Normal file
View File

@ -0,0 +1,172 @@
/* Copyright (C) 2019 Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef _LIBIGLOO__LOGCORE_H_
#define _LIBIGLOO__LOGCORE_H_
/**
* @file
* Put a good description of this file here
*/
#ifdef __cplusplus
extern "C" {
#endif
#include "ro.h"
#include "interface.h"
/* About thread safety:
* This set of functions is thread safe.
*/
igloo_RO_FORWARD_TYPE(igloo_logcore_t);
/* Routing classes allow controling the order in which messages should be routed to outputs */
typedef enum {
/* All messages are routed to outputs of the ANY class.
* However if one output accepts the message no additional ANY class outputs are tried.
*/
igloo_LOGCORE_CLASS_ANY,
/* In addition to all other classes all messages are routed to all outputs of the ALL class. */
igloo_LOGCORE_CLASS_ALL,
/* The DEFAULT class is part of the ANY class.
* The only difference is that outputs of the DEFAULT class are always tried last.
*/
igloo_LOGCORE_CLASS_DEFAULT
} igloo_logcore_routingclass_t;
/* Configuration structure of a single output */
typedef struct {
/* Optional: An ID for the output. This can be used to later on reference the output */
char *id;
/* Optional: A filename for the output. If not NULL the file is opened and the formater is attached to it */
char *filename;
/* Required: Routing class for the output. */
igloo_logcore_routingclass_t routingclass;
/* Optional: Limit for the recent buffer of the output or -1 to use the default. */
ssize_t recent_limit;
/* Optional: A filter that the messages that are routed to this output must pass. */
igloo_filter_t *filter;
/* Required: The formater to pass the message to. */
igloo_objecthandler_t *formater;
} igloo_logcore_output_t;
/* Type uses for callback called when a message is acknowledged.
*
* This callback can be used to generate a new message or trigger any action
* when another one is acknowledged.
*
* Parameters:
* core
* The core that emited the event.
* object
* The message that was acknowledged.
* userdata
* A pointer that was given on igloo_logcore_set_acknowledge_cb()
* Returns:
* A new message that will be pushed into the core or igloo_RO_NULL.
* A possible igloo_LOGMSG_OPT_ASKACK flag of the message will be ignored to avoid recursion.
*/
typedef igloo_ro_t (*igloo_logcore_acknowledge_t)(igloo_logcore_t *core, igloo_ro_t object, void *userdata);
/* Configure the core.
*
* Parameters:
* core
* The core to configure.
* recent_limit
* The limit for the recent message buffer or -1 for default.
* askack_limit
* The limit for the askack messages buffer or -1 for default.
* output_recent_limit
* The default limit for the per output recent message buffer or -1 for default.
* outputs
* The outputs to use.
* outputs_len
* The number of outputs to use.
*/
igloo_error_t igloo_logcore_configure(igloo_logcore_t *core, ssize_t recent_limit, ssize_t askack_limit, ssize_t output_recent_limit, const igloo_logcore_output_t *outputs, size_t outputs_len);
/* Set acknowledg callback.
*
* See also igloo_logcore_acknowledge_t.
*
* Parameters:
* core
* The core to configure.
* callback
* The callback to use.
* userdata
* The userdata pointer to pass to the callback.
*/
igloo_error_t igloo_logcore_set_acknowledge_cb(igloo_logcore_t *core, igloo_logcore_acknowledge_t callback, void *userdata);
/* Get a list of messages from the recent buffer.
*
* Parameters:
* core
* The core to access.
* type
* Filter messages to messages of this type or NULL to not filter.
* filter
* Filter messages using this filter or NULL to not filter.
* limit
* Limit messages to this amount or -1 to not limit.
* id
* Return messages from the output with this ID or NULL to return from the global buffer.
* Returns:
* Prefiltered list of messages.
*/
igloo_list_t * igloo_logcore_get_recent(igloo_logcore_t *core, const igloo_ro_type_t *type, igloo_filter_t *filter, ssize_t limit, const char *id);
/* Get a list of messages from the askack buffer.
*
* Parameters:
* core
* The core to access.
* type
* Filter messages to messages of this type or NULL to not filter.
* filter
* Filter messages using this filter or NULL to not filter.
* limit
* Limit messages to this amount or -1 to not limit.
* Returns:
* Prefiltered list of messages.
*/
igloo_list_t * igloo_logcore_get_askack(igloo_logcore_t *core, const igloo_ro_type_t *type, igloo_filter_t *filter, ssize_t limit);
/* Acknowledg a message in the askack buffer.
*
* Parameters:
* core
* The core to access.
* object
* The message to acknowledg.
*/
igloo_error_t igloo_logcore_acknowledge(igloo_logcore_t *core, igloo_ro_t object);
#ifdef __cplusplus
}
#endif
#endif /* ! _LIBIGLOO__LOGCORE_H_ */

2
include/igloo/types.h
View File

@ -43,6 +43,7 @@ typedef struct igloo_io_tag igloo_io_t;
typedef struct igloo_filter_tag igloo_filter_t;
typedef struct igloo_objecthandler_tag igloo_objecthandler_t;
typedef struct igloo_logmsg_tag igloo_logmsg_t;
typedef struct igloo_logcore_tag igloo_logcore_t;
typedef struct igloo_buffer_tag igloo_buffer_t;
typedef struct igloo_list_tag igloo_list_t;
@ -72,6 +73,7 @@ typedef union __attribute__ ((__transparent_union__)) {
igloo_RO_TYPE(igloo_filter_t)
igloo_RO_TYPE(igloo_objecthandler_t)
igloo_RO_TYPE(igloo_logmsg_t)
igloo_RO_TYPE(igloo_logcore_t)
igloo_RO_TYPE(igloo_buffer_t)
igloo_RO_TYPE(igloo_list_t)
igloo_RO_TYPE(igloo_reportxml_t)

413
src/logcore.c Normal file
View File

@ -0,0 +1,413 @@
/* Icecast
*
* This program is distributed under the GNU General Public License, version 2.
* A copy of this license is included with this source.
*
* Copyright 2019, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <igloo/ro.h>
#include <igloo/logcore.h>
#include <igloo/list.h>
#include <igloo/filter.h>
#include <igloo/objecthandler.h>
#include <igloo/logmsg.h>
#include <igloo/stdio.h>
#include <igloo/error.h>
#include "private.h"
struct igloo_logcore_tag {
igloo_ro_base_t __base;
igloo_rwlock_t rwlock;
igloo_list_t *global_recent;
igloo_list_t *global_askack;
size_t output_length;
igloo_logcore_output_t *output;
igloo_list_t **output_recent;
igloo_logcore_acknowledge_t acknowledge_cb;
void *acknowledge_cb_userdata;
};
static int __new(igloo_ro_t self, const igloo_ro_type_t *type, va_list ap);
static void __free(igloo_ro_t self);
static igloo_ro_t __get_interface_t(igloo_ro_t self, const igloo_ro_type_t *type, const char *name, igloo_ro_t associated, igloo_ro_t instance);
igloo_RO_PUBLIC_TYPE(igloo_logcore_t,
igloo_RO_TYPEDECL_FREE(__free),
igloo_RO_TYPEDECL_NEW(__new),
igloo_RO_TYPEDECL_GET_INTERFACE(__get_interface_t)
);
static int __copy_output(igloo_logcore_output_t *dst, const igloo_logcore_output_t *src)
{
memset(dst, 0, sizeof(*dst));
if (src->id)
dst->id = strdup(src->id);
if (src->filename)
dst->filename = strdup(src->filename);
dst->recent_limit = src->recent_limit;
dst->routingclass = src->routingclass;
igloo_ro_ref(dst->filter = src->filter);
igloo_ro_ref(dst->formater = src->formater);
return 0;
}
static void __free_output(igloo_logcore_output_t *output)
{
free(output->id);
free(output->filename);
igloo_ro_unref(output->filter);
igloo_objecthandler_flush(output->formater);
igloo_ro_unref(output->formater);
memset(output, 0, sizeof(*output));
}
static void __free_locked(igloo_logcore_t *core)
{
size_t i;
igloo_ro_unref(core->global_recent);
core->global_recent = NULL;
igloo_ro_unref(core->global_askack);
core->global_askack = NULL;
for (i = 0; i < core->output_length; i++) {
igloo_ro_unref(core->output_recent[i]);
__free_output(&(core->output[i]));
}
free(core->output);
core->output = NULL;
free(core->output_recent);
core->output_recent = NULL;
}
static int __new(igloo_ro_t self, const igloo_ro_type_t *type, va_list ap)
{
igloo_logcore_t *core = igloo_RO_TO_TYPE(self, igloo_logcore_t);
igloo_thread_rwlock_create(&(core->rwlock));
return 0;
}
static void __free(igloo_ro_t self)
{
igloo_logcore_t *core = igloo_RO_TO_TYPE(self, igloo_logcore_t);
igloo_thread_rwlock_wlock(&(core->rwlock));
__free_locked(core);
igloo_thread_rwlock_unlock(&(core->rwlock));
igloo_thread_rwlock_destroy(&(core->rwlock));
}
static igloo_filter_result_t __push_msg__output(igloo_logcore_t *core, igloo_ro_t msg, igloo_logcore_routingclass_t routingclass)
{
igloo_filter_result_t ret = igloo_FILTER_RESULT_DROP;
size_t i;
for (i = 0; i < core->output_length; i++) {
igloo_filter_result_t push = igloo_FILTER_RESULT_PASS;
if (core->output[i].routingclass != routingclass)
continue;
if (core->output[i].filter)
push = igloo_filter_test(core->output[i].filter, msg);
if (push == igloo_FILTER_RESULT_PASS)
push = igloo_objecthandler_handle(core->output[i].formater, msg);
igloo_list_push(core->output_recent[i], msg);
if (push == igloo_FILTER_RESULT_PASS) {
switch (routingclass) {
case igloo_LOGCORE_CLASS_ANY:
case igloo_LOGCORE_CLASS_DEFAULT:
return push;
break;
default:
ret = push;
break;
}
}
}
return ret;
}
static igloo_filter_result_t __push_msg(igloo_logcore_t *core, igloo_ro_t msg, int allow_askack)
{
igloo_filter_result_t ret = igloo_FILTER_RESULT_DROP;
igloo_filter_result_t res;
igloo_logmsg_t *logmsg;
ret = __push_msg__output(core, msg, igloo_LOGCORE_CLASS_ANY);
if (ret != igloo_FILTER_RESULT_PASS)
ret = __push_msg__output(core, msg, igloo_LOGCORE_CLASS_DEFAULT);
res = __push_msg__output(core, msg, igloo_LOGCORE_CLASS_ALL);
if (res == igloo_FILTER_RESULT_PASS)
ret = igloo_FILTER_RESULT_PASS;
if (ret == igloo_FILTER_RESULT_PASS)
igloo_list_push(core->global_recent, msg);
logmsg = igloo_RO_TO_TYPE(msg, igloo_logmsg_t);
if (logmsg) {
igloo_logmsg_opt_t opts = igloo_LOGMSG_OPT_NONE;
if (igloo_logmsg_get_extra(logmsg, &opts, NULL) == 0) {
if (opts & igloo_LOGMSG_OPT_ASKACK)
igloo_list_push(core->global_askack, msg);
}
}
return ret;
}
igloo_error_t igloo_logcore_configure(igloo_logcore_t *core, ssize_t recent_limit, ssize_t askack_limit, ssize_t output_recent_limit, const igloo_logcore_output_t *outputs, size_t outputs_len)
{
igloo_list_t *global_recent;
igloo_list_t *global_askack;
igloo_logcore_output_t *output;
igloo_list_t **output_recent;
igloo_ro_t instance;
size_t i;
if (!igloo_RO_IS_VALID(core, igloo_logcore_t))
return igloo_ERROR_FAULT;
if (outputs_len < 1 && !outputs)
return igloo_ERROR_INVAL;
if (recent_limit < 0)
recent_limit = 128;
if (askack_limit < 0)
askack_limit = 128;
if (output_recent_limit < 0)
output_recent_limit = 128;
instance = igloo_ro_get_instance(core);
global_recent = igloo_ro_new_ext(igloo_list_t, NULL, igloo_RO_NULL, core);
igloo_list_set_policy(global_recent, igloo_LIST_POLICY_FIXED_PIPE, recent_limit);
global_askack = igloo_ro_new_ext(igloo_list_t, NULL, igloo_RO_NULL, core);
igloo_list_set_policy(global_askack, igloo_LIST_POLICY_FIXED_PIPE, askack_limit);
output = calloc(outputs_len, sizeof(*output));
output_recent = calloc(outputs_len, sizeof(*output_recent));
for (i = 0; i < outputs_len; i++) {
igloo_io_t *io;
__copy_output(&(output[i]), &(outputs[i]));
if (output[i].recent_limit < 0)
output[i].recent_limit = output_recent_limit;
if (output[i].filename) {
io = igloo_stdio_new_file(output[i].filename, "ab", NULL, igloo_RO_NULL, instance);
if (io) {
igloo_objecthandler_set_backend(output[i].formater, io);
igloo_ro_unref(io);
}
}
output_recent[i] = igloo_ro_new_ext(igloo_list_t, NULL, igloo_RO_NULL, core);
igloo_list_set_policy(output_recent[i], igloo_LIST_POLICY_FIXED_PIPE, output[i].recent_limit);
}
igloo_thread_rwlock_wlock(&(core->rwlock));
__free_locked(core);
core->global_recent = global_recent;
core->global_askack = global_askack;
core->output_length = outputs_len;
core->output = output;
core->output_recent = output_recent;
igloo_thread_rwlock_unlock(&(core->rwlock));
igloo_ro_unref(instance);
return igloo_ERROR_NONE;
}
igloo_error_t igloo_logcore_set_acknowledge_cb(igloo_logcore_t *core, igloo_logcore_acknowledge_t callback, void *userdata)
{
if (!igloo_RO_IS_VALID(core, igloo_logcore_t))
return igloo_ERROR_FAULT;
igloo_thread_rwlock_wlock(&(core->rwlock));
core->acknowledge_cb = callback;
core->acknowledge_cb_userdata = userdata;
igloo_thread_rwlock_unlock(&(core->rwlock));
return igloo_ERROR_NONE;
}
static igloo_list_t *__copy_filtered_list(igloo_list_t *list, const igloo_ro_type_t *type, igloo_filter_t *filter, ssize_t limit)
{
igloo_list_iterator_storage_t storage;
igloo_list_iterator_t *iterator;
igloo_list_t *ret;
if (!list)
return NULL;
iterator = igloo_list_iterator_start(list, &storage, sizeof(storage));
ret = igloo_ro_new_ext(igloo_list_t, NULL, igloo_RO_NULL, list);
if (iterator && ret) {
while (limit) {
igloo_ro_t element = igloo_list_iterator_next(iterator);
if (igloo_RO_IS_NULL(element))
break;
if (type == NULL || igloo_RO_GET_TYPE(element) == type) {
if (filter == NULL || igloo_filter_test(filter, element) == igloo_FILTER_RESULT_PASS) {
igloo_list_push(ret, element);
}
}
igloo_ro_unref(element);
if (limit > 0)
limit--;
}
}
igloo_list_iterator_end(iterator);
return ret;
}
igloo_list_t * igloo_logcore_get_recent(igloo_logcore_t *core, const igloo_ro_type_t *type, igloo_filter_t *filter, ssize_t limit, const char *id)
{
igloo_list_t *list = NULL;
igloo_list_t *ret = NULL;
if (!igloo_RO_IS_VALID(core, igloo_logcore_t))
return NULL;
igloo_thread_rwlock_rlock(&(core->rwlock));
if (id) {
size_t i;
for (i = 0; i < core->output_length; i++) {
if (core->output[i].id && strcmp(core->output[i].id, id) == 0) {
list = core->output_recent[i];
}
}
} else {
list = core->global_recent;
}
ret = __copy_filtered_list(list, type, filter, limit);
igloo_thread_rwlock_unlock(&(core->rwlock));
return ret;
}
igloo_list_t * igloo_logcore_get_askack(igloo_logcore_t *core, const igloo_ro_type_t *type, igloo_filter_t *filter, ssize_t limit)
{
igloo_list_t *ret = NULL;
if (!igloo_RO_IS_VALID(core, igloo_logcore_t))
return NULL;
igloo_thread_rwlock_rlock(&(core->rwlock));
ret = __copy_filtered_list(core->global_askack, type, filter, limit);
igloo_thread_rwlock_unlock(&(core->rwlock));
return ret;
}
igloo_error_t igloo_logcore_acknowledge(igloo_logcore_t *core, igloo_ro_t object)
{
int ret;
if (!igloo_RO_IS_VALID(core, igloo_logcore_t))
return igloo_ERROR_FAULT;
igloo_thread_rwlock_wlock(&(core->rwlock));
ret = igloo_list_remove(core->global_askack, object);
if (ret == 0 && core->acknowledge_cb) {
igloo_ro_t msg = core->acknowledge_cb(core, object, core->acknowledge_cb_userdata);
if (!igloo_RO_IS_NULL(msg)) {
__push_msg(core, msg, 0);
}
}
igloo_thread_rwlock_unlock(&(core->rwlock));
return ret == 0 ? igloo_ERROR_NONE : igloo_ERROR_GENERIC;
}
static igloo_filter_result_t __handle(igloo_INTERFACE_BASIC_ARGS, igloo_ro_t object)
{
igloo_logcore_t *core = igloo_RO_TO_TYPE(*backend_object, igloo_logcore_t);
igloo_filter_result_t ret;
if (!core)
return igloo_FILTER_RESULT_ERROR;
igloo_thread_rwlock_wlock(&(core->rwlock));
ret = __push_msg(core, object, 1);
igloo_thread_rwlock_unlock(&(core->rwlock));
return ret;
}
static int __flush(igloo_INTERFACE_BASIC_ARGS)
{
igloo_logcore_t *core = igloo_RO_TO_TYPE(*backend_object, igloo_logcore_t);
size_t i;
if (!core)
return -1;
igloo_thread_rwlock_rlock(&(core->rwlock));
for (i = 0; i < core->output_length; i++) {
igloo_objecthandler_flush(core->output[i].formater);
}
igloo_thread_rwlock_unlock(&(core->rwlock));
return 0;
}
static const igloo_objecthandler_ifdesc_t igloo_logcore__igloo_objecthandler_ifdesc = {
igloo_INTERFACE_DESCRIPTION_BASE(igloo_objecthandler_ifdesc_t),
.is_thread_safe = 1,
.handle = __handle,
.flush = __flush,
.set_backend = NULL /* No, this is not possible */
};
static igloo_ro_t __get_interface_t(igloo_ro_t self, const igloo_ro_type_t *type, const char *name, igloo_ro_t associated, igloo_ro_t instance)
{
igloo_logcore_t *core = igloo_RO_TO_TYPE(self, igloo_logcore_t);
if (!core)
return igloo_RO_NULL;
if (type != igloo_RO_GET_TYPE_BY_SYMBOL(igloo_objecthandler_t))
return igloo_RO_NULL;
return (igloo_ro_t)igloo_objecthandler_new(&igloo_logcore__igloo_objecthandler_ifdesc, core, NULL, name, associated, instance);
}