/**
* poll info peer has information
* */
int network_poll(void* caller, void **udata,
const int msec_timeout,
int (*func_process) (void *caller,
void* nethandle,
const char* buf,
unsigned int len),
void (*func_process_connection) (void *,
void* nethandle,
char *ip,
int port)
)
{
client_t* me = *udata;
hashmap_iterator_t iter;
/* loop throught each connection for this peer */
for (
hashmap_iterator(me->connections, &iter);
hashmap_iterator_has_next(me->connections, &iter);
)
{
client_connection_t* cn;
cn = hashmap_iterator_next_value(me->connections, &iter);
/* we need to process a connection request created by the peer */
if (0 == cn->connect_status)
{
char ip[32];
sprintf(ip, "%p", cn->nethandle);
#if 0 /* debugging */
printf("processing connection me:%d them:%d\n",
me->nethandle, cn->nethandle);
#endif
func_process_connection(me->bt, cn->nethandle, ip, 4000);
cn->connect_status = CS_CONNECTED;
}
else if (!bipbuf_is_empty(cn->inbox))
{
int len = bipbuf_get_spaceused(cn->inbox);
if (0 < len)
func_process(me->bt,
(char*)cn->nethandle,
(char*)bipbuf_poll(cn->inbox, len), len);
}
}
return 1;
}
/* Reads a particular worker thread's available bipbuf bytes. Parses each log
* entry into the watcher buffers.
*/
static int logger_thread_read(logger *l, struct logger_stats *ls) {
unsigned int size;
unsigned int pos = 0;
unsigned char *data;
char scratch[LOGGER_PARSE_SCRATCH];
logentry *e;
pthread_mutex_lock(&l->mutex);
data = bipbuf_peek_all(l->buf, &size);
pthread_mutex_unlock(&l->mutex);
if (data == NULL) {
return 0;
}
L_DEBUG("LOGGER: Got %d bytes from bipbuffer\n", size);
/* parse buffer */
while (pos < size && watcher_count > 0) {
enum logger_parse_entry_ret ret;
int scratch_len = 0;
e = (logentry *) (data + pos);
ret = logger_thread_parse_entry(e, ls, scratch, &scratch_len);
if (ret != LOGGER_PARSE_ENTRY_OK) {
/* TODO: stats counter */
fprintf(stderr, "LOGGER: Failed to parse log entry\n");
} else {
logger_thread_write_entry(e, ls, scratch, scratch_len);
}
pos += sizeof(logentry) + e->size;
}
assert(pos <= size);
pthread_mutex_lock(&l->mutex);
data = bipbuf_poll(l->buf, size);
ls->worker_written += l->written;
ls->worker_dropped += l->dropped;
l->written = 0;
l->dropped = 0;
pthread_mutex_unlock(&l->mutex);
if (data == NULL) {
fprintf(stderr, "LOGGER: unexpectedly couldn't advance buf pointer\n");
assert(0);
}
return size; /* maybe the count of objects iterated? */
}
/* Since the event loop code isn't reusable without a refactor, and we have a
* limited number of potential watchers, we run our own poll loop.
* This calls poll() unnecessarily during write flushes, should be possible to
* micro-optimize later.
*
* This flushes buffers attached to watchers, iterating through the bytes set
* to each worker. Also checks for readability in case client connection was
* closed.
*
* Allows a specific watcher to be flushed (if buf full)
*/
static int logger_thread_poll_watchers(int force_poll, int watcher) {
int x;
int nfd = 0;
unsigned char *data;
unsigned int data_size = 0;
int flushed = 0;
for (x = 0; x < WATCHER_LIMIT; x++) {
logger_watcher *w = watchers[x];
if (w == NULL || (watcher != WATCHER_ALL && x != watcher))
continue;
data = bipbuf_peek_all(w->buf, &data_size);
if (data != NULL) {
watchers_pollfds[nfd].fd = w->sfd;
watchers_pollfds[nfd].events = POLLOUT;
nfd++;
} else if (force_poll) {
watchers_pollfds[nfd].fd = w->sfd;
watchers_pollfds[nfd].events = POLLIN;
nfd++;
}
/* This gets set after a call to poll, and should be used to gate on
* calling poll again.
*/
w->failed_flush = false;
}
if (nfd == 0)
return 0;
//L_DEBUG("LOGGER: calling poll() [data_size: %d]\n", data_size);
int ret = poll(watchers_pollfds, nfd, 0);
if (ret < 0) {
perror("something failed with logger thread watcher fd polling");
return -1;
}
nfd = 0;
for (x = 0; x < WATCHER_LIMIT; x++) {
logger_watcher *w = watchers[x];
if (w == NULL)
continue;
data_size = 0;
/* Early detection of a disconnect. Otherwise we have to wait until
* the next write
*/
if (watchers_pollfds[nfd].revents & POLLIN) {
char buf[1];
int res = read(w->sfd, buf, 1);
if (res == 0 || (res == -1 && (errno != EAGAIN && errno != EWOULDBLOCK))) {
L_DEBUG("LOGGER: watcher closed remotely\n");
logger_thread_close_watcher(w);
nfd++;
continue;
}
}
if ((data = bipbuf_peek_all(w->buf, &data_size)) != NULL) {
if (watchers_pollfds[nfd].revents & (POLLHUP|POLLERR)) {
L_DEBUG("LOGGER: watcher closed during poll() call\n");
logger_thread_close_watcher(w);
} else if (watchers_pollfds[nfd].revents & POLLOUT) {
int total = 0;
/* We can write a bit. */
switch (w->t) {
case LOGGER_WATCHER_STDERR:
total = fwrite(data, 1, data_size, stderr);
break;
case LOGGER_WATCHER_CLIENT:
total = write(w->sfd, data, data_size);
break;
}
L_DEBUG("LOGGER: poll() wrote %d to %d (data_size: %d) (bipbuf_used: %d)\n", total, w->sfd,
data_size, bipbuf_used(w->buf));
if (total == -1) {
if (errno != EAGAIN && errno != EWOULDBLOCK) {
logger_thread_close_watcher(w);
}
L_DEBUG("LOGGER: watcher hit EAGAIN\n");
} else if (total == 0) {
logger_thread_close_watcher(w);
} else {
bipbuf_poll(w->buf, total);
flushed += total;
}
}
}
nfd++;
}
return flushed;
}
