mirror of
https://github.com/servalproject/serval-dna.git
synced 2024-12-21 06:03:12 +00:00
a79156c4d0
The daemon API is built as a Swift module called ServalDNA. The new CliContext class allows easy implementation of CLI output using Swift code. The new CliContextFile subclass is the obvious first implementation, equivalent to cli_stdio.c. The 'servaldswift' executable now uses CliContextFile to print its CLI output to standard output. The new delegated log output support constructs each log line in a buffer and prints it by calling the delegate's 'print' function at end-of-line. The 'servaldswift' executable now provides a log output delegate in Swift that simply prints to standard error, replacing log_output_console.o, which is omitted from its link.
135 lines
3.7 KiB
C
135 lines
3.7 KiB
C
/*
|
|
Serval DNA logging output to a delegate
|
|
Copyright 2017 Flinders University
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "log.h"
|
|
#include "log_output.h"
|
|
#include "log_output_delegate.h"
|
|
#include "strbuf.h"
|
|
|
|
/* An implementation of the Serval logging API that constructs log messages in
|
|
* a buffer then passes the buffer to a delegate.
|
|
*/
|
|
|
|
/* Private state for delegate log output.
|
|
*/
|
|
|
|
struct log_output_delegate_state {
|
|
bool_t opened;
|
|
// Buffer to hold log messages before the log file is open and ready for writing:
|
|
struct strbuf strbuf;
|
|
char buf[8192];
|
|
};
|
|
|
|
static struct log_output_delegate_state static_state = {
|
|
.opened = 0,
|
|
.strbuf = STRUCT_STRBUF_EMPTY,
|
|
.buf = ""
|
|
};
|
|
|
|
/* Functions for querying configuration.
|
|
*/
|
|
|
|
static int log_delegate_minimum_level(const struct log_output *UNUSED(out))
|
|
{
|
|
return serval_log_delegate.minimum_level;
|
|
}
|
|
|
|
static bool_t log_delegate_show_pid(const struct log_output *UNUSED(out))
|
|
{
|
|
return serval_log_delegate.show_pid;
|
|
}
|
|
|
|
static bool_t log_delegate_show_time(const struct log_output *UNUSED(out))
|
|
{
|
|
return serval_log_delegate.show_time;
|
|
}
|
|
|
|
/* Log output operations.
|
|
*/
|
|
|
|
static inline struct log_output_delegate_state *_state(struct log_output *out)
|
|
{
|
|
assert(out->state);
|
|
return (struct log_output_delegate_state *)(out->state);
|
|
}
|
|
|
|
static bool_t is_log_delegate_available(const struct log_output_iterator *UNUSED(it))
|
|
{
|
|
return serval_log_delegate.print != NULL;
|
|
}
|
|
|
|
static void log_delegate_open(struct log_output_iterator *it)
|
|
{
|
|
struct log_output_delegate_state *state = _state(*it->output);
|
|
if (!state->opened) {
|
|
state->opened = 1;
|
|
if (serval_log_delegate.show_prolog)
|
|
serval_log_print_prolog(it);
|
|
}
|
|
}
|
|
|
|
static void log_delegate_start_line(struct log_output_iterator *it, int UNUSED(level))
|
|
{
|
|
struct log_output_delegate_state *state = _state(*it->output);
|
|
strbuf sb = &state->strbuf;
|
|
assert(strbuf_len(sb) == 0);
|
|
strbuf_init(sb, state->buf, sizeof state->buf);
|
|
it->xpf = XPRINTF_STRBUF(sb);
|
|
}
|
|
|
|
static void log_delegate_end_line(struct log_output_iterator *it, int level)
|
|
{
|
|
struct log_output_delegate_state *state = _state(*it->output);
|
|
strbuf sb = &state->strbuf;
|
|
serval_log_delegate.print(level, strbuf_str(sb), strbuf_overrun(sb));
|
|
strbuf_reset(sb);
|
|
}
|
|
|
|
static void flush_log_delegate(struct log_output_iterator *UNUSED(it))
|
|
{
|
|
if (serval_log_delegate.flush)
|
|
serval_log_delegate.flush();
|
|
}
|
|
|
|
static struct log_output static_log_output = {
|
|
.minimum_level = log_delegate_minimum_level,
|
|
.show_pid = log_delegate_show_pid,
|
|
.show_time = log_delegate_show_time,
|
|
.state = &static_state,
|
|
.open = log_delegate_open,
|
|
.capture_fd = NULL,
|
|
.is_available = is_log_delegate_available,
|
|
.start_line = log_delegate_start_line,
|
|
.end_line = log_delegate_end_line,
|
|
.flush = flush_log_delegate,
|
|
.close = NULL
|
|
};
|
|
|
|
DEFINE_LOG_OUTPUT(&static_log_output);
|
|
|
|
// These are defaults only; the delegate fills this in as it wishes.
|
|
struct log_delegate serval_log_delegate = {
|
|
.minimum_level = LOG_LEVEL_INFO,
|
|
.show_prolog = 1,
|
|
.show_pid = 0,
|
|
.show_time = 1,
|
|
.print = NULL,
|
|
.flush = NULL
|
|
};
|