void finalize()
{
for (auto& child : mChildren)
{
child.finalize();
}
do_finalize();
}
void logger::finalize()
{
if (!m_initialized)
return;
std::lock_guard<std::mutex> g(m_mutex);
if (!m_initialized)
return;
m_abort = true;
if (m_thread)
m_thread->join();
m_thread.reset();
do_finalize();
m_abort = false;
m_initialized = false;
}
void do_process(connection_t *con)
{
drizzle_st *drizzle;
drizzle_return_t ret;
drizzle_con_st *dc = con->dc;
drizzle_command_t command;
uint8_t *data = NULL;
size_t total;
dbgin();
drizzle = con->client->drizzle;
/*
ret = drizzle_con_wait(drizzle);
if (ret != DRIZZLE_RETURN_OK) {
printf("drizzle_con_wait failed:%s\n", drizzle_error(drizzle));
return;
}
*/
while (1) {
switch (con->state) {
case INIT:
/* Handshake packets */
drizzle_con_set_protocol_version(dc, 10);
drizzle_con_set_server_version(dc, "ev_drizzle_server demo 0.0.1");
drizzle_con_set_thread_id(dc, 1);
drizzle_con_set_scramble(dc, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
drizzle_con_set_capabilities(dc, DRIZZLE_CAPABILITIES_NONE);
drizzle_con_set_charset(dc, 8);
drizzle_con_set_status(dc, DRIZZLE_CON_STATUS_NONE);
drizzle_con_set_max_packet_size(dc, DRIZZLE_MAX_PACKET_SIZE);
con->state = HANDSHAKE_WRITE;
break;
case HANDSHAKE_WRITE:
printf("handshake write\n");
ret = drizzle_handshake_server_write(dc);
if (ret == DRIZZLE_RETURN_IO_WAIT) {
return;
}
if (ret == DRIZZLE_RETURN_OK) {
stop_watch_write(con);
con->state = HANDSHAKE_READ;
break;
}
printf("drizzle_handshake_server_write error:%s",
drizzle_error(drizzle));
exit(1);
break;
case HANDSHAKE_READ:
printf("handshake read\n");
/* prepare libdrizzle internal event */
dc->revents |= POLLIN;
ret = drizzle_handshake_client_read(dc);
if (ret == DRIZZLE_RETURN_IO_WAIT) {
return;
}
if (ret == DRIZZLE_RETURN_OK) {
con->state = HANDSHAKE_DONE;
break;
}
printf("drizzle_handshake_server_read error:%s",
drizzle_error(drizzle));
exit(1);
break;
case HANDSHAKE_DONE:
printf("handshake done\n");
con->result = (drizzle_result_st *)
malloc(sizeof(drizzle_result_st));
if (drizzle_result_create(dc, con->result) == NULL) {
printf("drizzle_result_create error:%s",
drizzle_error(drizzle));
exit(1);
}
ret = drizzle_result_write(dc, con->result, true);
if (ret != DRIZZLE_RETURN_OK) {
printf("drizzle_result_write error:%s",
drizzle_error(drizzle));
exit(1);
}
con->state = PREPARE_COMMAND;
break;
case PREPARE_COMMAND:
printf("prepare command\n");
/* prepare libdrizzle internal event */
dc->revents |= POLLIN;
drizzle_result_free(dc->result);
data = (uint8_t *) drizzle_con_command_buffer(dc, &command,
&total, &ret);
if (ret == DRIZZLE_RETURN_LOST_CONNECTION ||
(ret == DRIZZLE_RETURN_OK &&
command == DRIZZLE_COMMAND_QUIT))
{
free(data);
do_finalize(con);
return;
}
if (ret == DRIZZLE_RETURN_IO_WAIT) {
return;
}
printf("Command data:%s\n", data);
if (drizzle_result_create(dc, con->result) == NULL) {
printf("drizzle_result_create error:%s",
drizzle_error(drizzle));
exit(1);
}
if (command != DRIZZLE_COMMAND_QUERY) {
printf("command is not QUERY command\n");
ret = drizzle_result_write(dc, dc->result, true);
if (ret != DRIZZLE_RETURN_OK) {
printf("drizzle_result_write error:%s",
drizzle_error(drizzle));
exit(1);
}
continue;
}
ret = drizzle_result_write(dc, dc->result, true);
if (ret != DRIZZLE_RETURN_OK) {
printf("drizzle_result_write error:%s",
drizzle_error(drizzle));
exit(1);
}
return;
break;
default:
printf("Unsupported state %d\n", con->state);
//sleep(10);
}
}
}
void logger::init(const config_tree& a_cfg, const sigset_t* a_ignore_signals,
bool a_install_finalizer)
{
if (m_initialized)
throw std::runtime_error("Logger already initialized!");
std::lock_guard<std::mutex> guard(m_mutex);
do_finalize();
try {
m_show_location = a_cfg.get<bool> ("logger.show-location", m_show_location);
m_show_fun_namespaces = a_cfg.get<int> ("logger.show-fun-namespaces",
m_show_fun_namespaces);
m_show_category = a_cfg.get<bool> ("logger.show-category", m_show_category);
m_show_ident = a_cfg.get<bool> ("logger.show-ident", m_show_ident);
m_show_thread = a_cfg.get<bool> ("logger.show-thread", m_show_thread);
m_fatal_kill_signal = a_cfg.get<int> ("logger.fatal-kill-signal",m_fatal_kill_signal);
m_ident = a_cfg.get<std::string>("logger.ident", m_ident);
m_ident = replace_macros(m_ident);
std::string ts = a_cfg.get<std::string>("logger.timestamp", "time-usec");
m_timestamp_type = parse_stamp_type(ts);
std::string levs = a_cfg.get<std::string>("logger.levels", "");
if (!levs.empty())
set_level_filter(static_cast<log_level>(parse_log_levels(levs)));
std::string ls = a_cfg.get<std::string>("logger.min-level-filter", "info");
if (!levs.empty() && !ls.empty())
std::runtime_error
("Either 'levels' or 'min-level-filter' option is permitted!");
set_min_level_filter(parse_log_level(ls));
long timeout_ms = a_cfg.get<int> ("logger.wait-timeout-ms", 1000);
m_wait_timeout = timespec{timeout_ms / 1000, timeout_ms % 1000 * 1000000L};
m_sched_yield_us = a_cfg.get<long> ("logger.sched-yield-us", -1);
m_silent_finish = a_cfg.get<bool> ("logger.silent-finish", false);
m_block_signals = a_cfg.get<bool> ("logger.block-signals", true);
if ((int)m_timestamp_type < 0)
throw std::runtime_error("Invalid timestamp type: " + ts);
// Install crash signal handlers
// (SIGABRT, SIGFPE, SIGILL, SIGSEGV, SIGTERM)
if (a_cfg.get("logger.handle-crash-signals", true)) {
sigset_t sset = sig_members_parse
(a_cfg.get("logger.handle-crash-signals.signals",""), UTXX_SRC);
// Remove signals from the sset that are handled externally
if (a_ignore_signals)
for (uint i=1; i < sig_names_count(); ++i)
if (sigismember(a_ignore_signals, i))
sigdelset(&sset, i);
if (install_sighandler(true, &sset)) {
auto old = m_crash_sigset.exchange(new sigset_t(sset));
if (!old)
delete old;
}
}
//logger_impl::msg_info info(NULL, 0);
//query_timestamp(info);
logger_impl_mgr& lim = logger_impl_mgr::instance();
std::lock_guard<std::mutex> guard(lim.mutex());
// Check the list of registered implementations. If corresponding
// configuration section is found, initialize the implementation.
for(logger_impl_mgr::impl_map_t::iterator it=lim.implementations().begin();
it != lim.implementations().end();
++it)
{
std::string path = std::string("logger.") + it->first;
if (a_cfg.get_child_optional(path)) {
// Determine if implementation of this type is already
// registered with the logger
bool found = false;
for(implementations_vector::iterator
im = m_implementations.begin(), iend = m_implementations.end();
im != iend; ++im)
if (it->first == (*im)->name()) {
found = true;
break;
}
if (found)
throw badarg_error("Implementation '", it->first,
"' is already registered with the logger!");
// A call to it->second() creates a logger_impl* pointer.
// We need to call implementation's init function that may throw,
// so use RAII to guarantee proper cleanup.
logger_impl_mgr::impl_callback_t& f = it->second;
m_implementations.emplace_back( f(it->first.c_str()) );
auto& i = m_implementations.back();
i->set_log_mgr(this);
i->init(a_cfg);
}
}
m_initialized = true;
m_abort = false;
m_thread.reset(new std::thread([this]() {
this->run();
}));
if (!m_finalizer_installed && a_install_finalizer) {
atexit(&finalize_logger_at_exit);
m_finalizer_installed = true;
}
} catch (std::runtime_error& e) {
if (m_error)
m_error(e.what());
else
throw;
}
}
