/**
* Put this message from nethandle onto my inbox for this nethandle
* param nethandle: the nethandle that sent us this data */
static void __offer_inbox(client_t* me, const void* send_data, int len, void* nethandle)
{
client_connection_t* cn;
assert(me->connections);
cn = hashmap_get(me->connections, nethandle);
assert(cn);
bipbuf_offer(cn->inbox, send_data, len);
#if 0 /* debuggin */
printf("|inbox me:%d rawpeer:%d peer:%d inbox:%d %dB",
me->nethandle, nethandle, cn->nethandle, bipbuf_get_spaceused(cn->inbox), len);
for (ii=0; ii<len; ii++)
printf("%c", ((char*)send_data)[ii]);
printf("\n");
__print_client_contents();
#endif
}
/* Writes flattened entry to available watchers */
static void logger_thread_write_entry(logentry *e, struct logger_stats *ls,
char *scratch, int scratch_len) {
int x, total;
/* Write the line into available watchers with matching flags */
for (x = 0; x < WATCHER_LIMIT; x++) {
logger_watcher *w = watchers[x];
char *skip_scr = NULL;
if (w == NULL || (e->eflags & w->eflags) == 0)
continue;
/* Avoid poll()'ing constantly when buffer is full by resetting a
* flag periodically.
*/
while (!w->failed_flush &&
(skip_scr = (char *) bipbuf_request(w->buf, scratch_len + 128)) == NULL) {
if (logger_thread_poll_watchers(0, x) <= 0) {
L_DEBUG("LOGGER: Watcher had no free space for line of size (%d)\n", scratch_len + 128);
w->failed_flush = true;
}
}
if (w->failed_flush) {
L_DEBUG("LOGGER: Fast skipped for watcher [%d] due to failed_flush\n", w->sfd);
w->skipped++;
ls->watcher_skipped++;
continue;
}
if (w->skipped > 0) {
total = snprintf(skip_scr, 128, "skipped=%llu\n", (unsigned long long) w->skipped);
if (total >= 128 || total <= 0) {
L_DEBUG("LOGGER: Failed to flatten skipped message into watcher [%d]\n", w->sfd);
w->skipped++;
ls->watcher_skipped++;
continue;
}
bipbuf_push(w->buf, total);
w->skipped = 0;
}
/* Can't fail because bipbuf_request succeeded. */
bipbuf_offer(w->buf, (unsigned char *) scratch, scratch_len);
ls->watcher_sent++;
}
}
/* Passes a client connection socket from a primary worker thread to the
* logger thread. Caller *must* event_del() the client before handing it over.
* Presently there's no way to hand the client back to the worker thread.
*/
enum logger_add_watcher_ret logger_add_watcher(void *c, const int sfd, uint16_t f) {
int x;
logger_watcher *w = NULL;
pthread_mutex_lock(&logger_stack_lock);
if (watcher_count >= WATCHER_LIMIT) {
return LOGGER_ADD_WATCHER_TOO_MANY;
}
for (x = 0; x < WATCHER_LIMIT-1; x++) {
if (watchers[x] == NULL)
break;
}
w = calloc(1, sizeof(logger_watcher));
if (w == NULL) {
pthread_mutex_unlock(&logger_stack_lock);
return LOGGER_ADD_WATCHER_FAILED;
}
w->c = c;
w->sfd = sfd;
if (sfd == 0 && c == NULL) {
w->t = LOGGER_WATCHER_STDERR;
} else {
w->t = LOGGER_WATCHER_CLIENT;
}
w->id = x;
w->eflags = f;
w->buf = bipbuf_new(settings.logger_watcher_buf_size);
if (w->buf == NULL) {
free(w);
pthread_mutex_unlock(&logger_stack_lock);
return LOGGER_ADD_WATCHER_FAILED;
}
bipbuf_offer(w->buf, (unsigned char *) "OK\r\n", 4);
watchers[x] = w;
watcher_count++;
/* Update what flags the global logs will watch */
logger_set_flags();
pthread_mutex_unlock(&logger_stack_lock);
return LOGGER_ADD_WATCHER_OK;
}
