flux_kvsitr_t *flux_kvsitr_create (const flux_kvsdir_t *dir)
{
flux_kvsitr_t *itr = NULL;
const char *key;
json_t *dirdata, *value;
if (!dir) {
errno = EINVAL;
goto error;
}
if (!(itr = calloc (1, sizeof (*itr))))
goto error;
if (!(itr->keys = zlist_new ()))
goto error;
dirdata = treeobj_get_data (dir->dirobj);
json_object_foreach (dirdata, key, value) {
if (zlist_push (itr->keys, (char *)key) < 0)
goto error;
}
zlist_sort (itr->keys, sort_cmp);
itr->reset = true;
return itr;
error:
flux_kvsitr_destroy (itr);
return NULL;
}
int
zmsg_pushstr (zmsg_t *self, const char *format, ...)
{
assert (self);
assert (format);
// Format string into buffer
va_list argptr;
va_start (argptr, format);
int size = 255 + 1;
char *string = (char *) malloc (size);
if (!string) {
va_end (argptr);
return -1;
}
int required = vsnprintf (string, size, format, argptr);
if (required >= size) {
size = required + 1;
string = (char *) realloc (string, size);
if (!string) {
va_end (argptr);
return -1;
}
vsnprintf (string, size, format, argptr);
}
va_end (argptr);
self->content_size += strlen (string);
zlist_push (self->frames, zframe_new (string, strlen (string)));
free (string);
return 0;
}
void *
zctx__socket_new (zctx_t *self, int type)
{
// Initialize context now if necessary
assert (self);
zmutex_lock (self->mutex);
if (!self->context)
self->context = zmq_init (self->iothreads);
zmutex_unlock (self->mutex);
if (!self->context)
return NULL;
// Create and register socket
void *zocket = zmq_socket (self->context, type);
if (!zocket)
return NULL;
#if (ZMQ_VERSION_MAJOR == 2)
// For ZeroMQ/2.x we use sndhwm for both send and receive
zsocket_set_hwm (zocket, self->sndhwm);
#else
// For later versions we use separate SNDHWM and RCVHWM
zsocket_set_sndhwm (zocket, self->sndhwm);
zsocket_set_rcvhwm (zocket, self->rcvhwm);
#endif
zmutex_lock (self->mutex);
if (zlist_push (self->sockets, zocket)) {
zmutex_unlock (self->mutex);
zmq_close (zocket);
return NULL;
}
zmutex_unlock (self->mutex);
return zocket;
}
int
zmsg_push (zmsg_t *self, zframe_t *frame)
{
assert (self);
assert (frame);
self->content_size += zframe_size (frame);
return zlist_push (self->frames, (void *) frame);
}
void
zmsg_pushmem (zmsg_t *self, const void *src, size_t size)
{
assert (self);
zframe_t *frame = zframe_new (src, size);
self->content_size += size;
zlist_push (self->frames, frame);
}
/* Don't reply to request - just queue it for later.
*/
static int clog_request_cb (flux_t h, int typemask, zmsg_t **zmsg, void *arg)
{
ctx_t *ctx = getctx (h);
if (zlist_push (ctx->clog_requests, *zmsg) < 0)
oom ();
*zmsg = NULL;
return 0;
}
static void
s_service_disable_command (service_t *self, const char *command)
{
char *item = (char *) zlist_first (self->blacklist);
while (item && !streq (item, command))
item = (char *) zlist_next (self->blacklist);
if (!item)
zlist_push (self->blacklist, strdup (command));
}
/* Don't reply to request - just queue it for later.
*/
void clog_request_cb (flux_t h, flux_msg_handler_t *w,
const flux_msg_t *msg, void *arg)
{
ctx_t *ctx = getctx (h);
flux_msg_t *cpy = flux_msg_copy (msg, true);
if (zlist_push (ctx->clog_requests, cpy) < 0)
oom ();
}
void flux_msg_handler_start (flux_msg_handler_t *w)
{
struct dispatch *d = w->d;
assert (w->magic == HANDLER_MAGIC);
flux_watcher_start (d->w);
if (zlist_push (d->handlers, w) < 0)
oom ();
}
int
zmsg_pushstr (zmsg_t *self, const char *string)
{
assert (self);
assert (zmsg_is (self));
assert (string);
self->content_size += strlen (string);
zlist_push (self->frames, zframe_new (string, strlen (string)));
return 0;
}
int
zmsg_pushmem (zmsg_t *self, const void *src, size_t size)
{
assert (self);
zframe_t *frame = zframe_new (src, size);
if (frame) {
self->content_size += size;
return zlist_push (self->frames, frame);
}
else
return -1;
}
int
zmsg_prepend (zmsg_t *self, zframe_t **frame_p)
{
assert (self);
assert (zmsg_is (self));
assert (frame_p);
zframe_t *frame = *frame_p;
*frame_p = NULL; // We now own frame
self->content_size += zframe_size (frame);
return zlist_push (self->frames, frame);
}
static vocket_t *
vocket_new (driver_t *driver, int socktype, char *vtxname)
{
assert (driver);
vocket_t *self = (vocket_t *) zmalloc (sizeof (vocket_t));
self->driver = driver;
self->vtxname = strdup (vtxname);
self->binding_hash = zhash_new ();
self->peering_hash = zhash_new ();
self->peering_list = zlist_new ();
self->live_peerings = zlist_new ();
self->socktype = socktype;
uint index;
for (index = 0; index < tblsize (s_vocket_config); index++)
if (socktype == s_vocket_config [index].socktype)
break;
if (index < tblsize (s_vocket_config)) {
self->routing = s_vocket_config [index].routing;
self->nomnom = s_vocket_config [index].nomnom;
self->min_peerings = s_vocket_config [index].min_peerings;
self->max_peerings = s_vocket_config [index].max_peerings;
}
else {
zclock_log ("E: invalid vocket type %d", socktype);
exit (1);
}
// Create msgpipe vocket and connect over inproc to vtxname
self->msgpipe = zsocket_new (driver->ctx, ZMQ_PAIR);
assert (self->msgpipe);
zsocket_connect (self->msgpipe, "inproc://%s", vtxname);
// If we drop on no peerings, start routing input now
if (self->min_peerings == 0) {
// Ask reactor to start monitoring vocket's msgpipe pipe
zmq_pollitem_t item = { self->msgpipe, 0, ZMQ_POLLIN, 0 };
zloop_poller (driver->loop, &item, s_vocket_input, self);
}
// Store this vocket per driver so that driver can cleanly destroy
// all its vockets when it is destroyed.
zlist_push (driver->vockets, self);
//* Start transport-specific work
self->inbuf_max = VTX_TCP_INBUF_MAX;
self->outbuf_max = VTX_TCP_OUTBUF_MAX;
//* End transport-specific work
return self;
}
void *
zctx__socket_new (zctx_t *self, int type)
{
assert (self);
// Initialize context now if necessary
if (self->context == NULL)
self->context = zmq_init (self->iothreads);
assert (self->context);
// Create and register socket
void *socket = zmq_socket (self->context, type);
assert (socket);
zlist_push (self->sockets, socket);
return socket;
}
int
zloop_timer (zloop_t *self, size_t delay, size_t times, zloop_fn handler, void *arg)
{
assert (self);
s_timer_t *timer = s_timer_new (delay, times, handler, arg);
if (!timer)
return -1;
if (zlist_push (self->timers, timer))
return -1;
if (self->verbose)
zclock_log ("I: zloop: register timer delay=%d times=%d", delay, times);
return 0;
}
int module_subscribe (modhash_t *mh, const char *uuid, const char *topic)
{
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
int rc = -1;
if (!p) {
errno = ENOENT;
goto done;
}
if (zlist_push (p->subs, xstrdup (topic)) < 0)
oom ();
rc = 0;
done:
return rc;
}
int
zmsg_pushstr (zmsg_t *self, const char *string)
{
assert (self);
assert (zmsg_is (self));
assert (string);
size_t len = strlen (string);
zframe_t *frame = zframe_new (string, len);
if (frame) {
self->content_size += len;
return zlist_push (self->frames, frame);
}
else
return -1;
}
int
zmsg_pushstrf (zmsg_t *self, const char *format, ...)
{
assert (self);
assert (zmsg_is (self));
assert (format);
va_list argptr;
va_start (argptr, format);
char *string = zsys_vprintf (format, argptr);
va_end (argptr);
self->content_size += strlen (string);
zlist_push (self->frames, zframe_new (string, strlen (string)));
free (string);
return 0;
}
zlist_t * fetch_rules(void * sock, char * channel) {
zlist_t * rules = zlist_new();
/* if(!endpoint) {
zclock_log("W: no reup endpoint defined, won't try te refresh rules");
return rules;
}*/
// zsocket_connect(sock, endpoint);
zstr_sendm(sock, "");
zstr_send(sock, channel);
zmsg_t * tmp;
// while(tmp=zmsg_recv(sock)) {
// zmsg_dump(tmp);
//}
// exit(1);
zmsg_t * msg = zmsg_recv(sock);
kill_envelope(msg);
char * status = zmsg_popstr(msg);
if(strcmp("200", status) != 0) {
zclock_log("W: reloading rules for %s failed: got |%s|", channel, status);
return rules;
}
free(status);
zmsg_destroy(&msg);
while((msg=zmsg_recv(sock))) {
zclock_log("once");
kill_envelope(msg);
zmsg_dump(msg);
zframe_t * header = zmsg_pop(msg);
if(zframe_streq(header, "")) {
// we're done
zclock_log("got a null header, we're out");
zframe_destroy(&header);
zmsg_destroy(&msg);
break;
}
zmsg_push(msg, header);
zlist_push(rules, msg);
}
return rules;
}
void reduce (flux_reduce_t *r, int batchnum, void *arg)
{
void *item;
zlist_t *tmp = zlist_new ();
if (!tmp)
oom ();
reduce_calls++;
while ((item = flux_reduce_pop (r))) {
if (zlist_push (tmp, item) < 0)
oom ();
reduce_items++;
}
while ((item = zlist_pop (tmp))) {
if (flux_reduce_push (r, item) < 0)
oom ();
}
zlist_destroy (&tmp);
}
int
zloop_poller (zloop_t *self, zmq_pollitem_t *item, zloop_fn handler, void *arg)
{
assert (self);
s_poller_t *poller = s_poller_new (item, handler, arg);
if (poller) {
if (zlist_push (self->pollers, poller))
return -1;
self->dirty = TRUE;
if (self->verbose)
zclock_log ("I: zloop: register %s poller (%p, %d)",
item->socket? zsocket_type_str (item->socket): "FD",
item->socket, item->fd);
assert (strneq (zsocket_type_str (item->socket), "UNKNOWN"));
return 0;
}
else
return -1;
}
void cleanup_push (cleaner_fun_f *fun, void * arg)
{
pthread_mutex_lock(&mutex);
if (! cleanup_list || cleaner_pid != getpid())
{
// This odd dance is to handle forked processes that do not exec
if (cleaner_pid != 0 && cleanup_list) {
zlist_destroy(&cleanup_list);
}
cleanup_list = zlist_new();
cleaner_pid = getpid();
atexit(cleanup);
}
struct cleaner * c = calloc(sizeof(struct cleaner), 1);
c->fun = fun;
c->arg = arg;
/* Ignore return code, no way to return it callery anyway... */
(void) zlist_push(cleanup_list, c);
pthread_mutex_unlock(&mutex);
}
void *
zctx__socket_new (zctx_t *self, int type)
{
// Initialize context now if necessary
assert (self);
if (!self->context)
self->context = zmq_init (self->iothreads);
if (!self->context)
return NULL;
// Create and register socket
void *zocket = zmq_socket (self->context, type);
if (!zocket)
return NULL;
zsocket_set_hwm (zocket, self->hwm);
if (zlist_push (self->sockets, zocket)) {
zmq_close (zocket);
return NULL;
}
return zocket;
}
static void
collect_data_to_send (client_t *self)
{
zsys_info ("read %d bytes", (int) zpipes_msg_size (self->request));
// Do we have enough data to satisfy the read request?
size_t required = zpipes_msg_size (self->request);
// If pipe was closed, we'll do a short read with as much
// data as we have pending
if (required > self->pending && self->pipe == NULL)
required = self->pending;
if (self->pipe == NULL && self->pending == 0)
engine_set_exception (self, pipe_shut_event);
else
if (self->pending >= required) {
// Create a bucket chunk with the required max size
zchunk_t *bucket = zchunk_new (NULL, required);
// Now fill the bucket with chunks from our queue
while (zchunk_size (bucket) < required) {
// Get next chunk and consume as much of it as possible
zchunk_t *chunk = (zchunk_t *) zlist_pop (self->queue);
assert (chunk);
zchunk_consume (bucket, chunk);
// If chunk is exhausted, destroy it
if (zchunk_exhausted (chunk))
zchunk_destroy (&chunk);
else {
// Push chunk back for next time
zlist_push (self->queue, chunk);
assert (zchunk_size (bucket) == required);
}
}
zpipes_msg_set_chunk (self->reply, &bucket);
self->pending -= required;
}
else
engine_set_exception (self, not_enough_data_event);
}
int
zmsg_pushstrf (zmsg_t *self, const char *format, ...)
{
assert (self);
assert (zmsg_is (self));
assert (format);
va_list argptr;
va_start (argptr, format);
char *string = zsys_vprintf (format, argptr);
va_end (argptr);
if (!string)
return -1;
size_t len = strlen (string);
zframe_t *frame = zframe_new (string, len);
free (string);
if (frame) {
self->content_size += len;
return zlist_push (self->frames, frame);
}
else
return -1;
}
JNIEXPORT jint JNICALL
Java_zlist__1_1push (JNIEnv *env, jclass c, jlong self, jlong item)
{
jint push_ = (jint) zlist_push ((zlist_t *) self, (void *) item);
return push_;
}
int rrwrk_start(rrwrk_t *self, wrk_task_fn *cb)
{
self->heartbeat_at = zclock_time() + self->heartbeat;
self->cb = cb;
//** Start task thread and wait for synchronization signal
self->pipe = zthread_fork(self->ctx, rrtask_manager_fn, (void *)self);
assert(self->pipe);
free(zstr_recv(self->pipe));
//self->liveness = HEARTBEAT_LIVENESS; //** Don't do reconnect before the first connection established
while(!zctx_interrupted) {
zmq_pollitem_t items[] = {{self->worker, 0, ZMQ_POLLIN, 0}, {self->pipe, 0, ZMQ_POLLIN, 0}}; //** Be aware: this must be within while loop!!
int rc = zmq_poll(items, 2, self->heartbeat * ZMQ_POLL_MSEC);
if (rc == -1)
break; //** Interrupted
if (items[0].revents & ZMQ_POLLIN) { //** Data from broker is ready
zmsg_t *msg = zmsg_recv(self->worker);
if (!msg)
break; //** Interrupted. Need to do more research to confirm it
self->liveness = HEARTBEAT_LIVENESS;
self->last_heartbeat = zclock_time();
//** Dont try to handle errors, just assert noisily
assert(zmsg_size(msg) >= 3); //** empty + header + command + ...
zframe_t *empty = zmsg_pop(msg);
assert(zframe_streq(empty, ""));
zframe_destroy(&empty);
zframe_t *header = zmsg_pop(msg);
assert(zframe_streq(header, RR_WORKER));
zframe_destroy(&header);
zframe_t *command = zmsg_pop(msg);
if (zframe_streq(command, RRWRK_REQUEST)) {
assert(zmsg_size(msg) == 3); //** UUID + SOURCE + INPUT DATA
self->total_received++;
zmq_pollitem_t item = {self->pipe, 0, ZMQ_POLLOUT, 0};
int rc = zmq_poll(&item, 1, 0);
assert(rc != -1);
if (item.revents & ZMQ_POLLOUT) { //** Dispatch it if worker is ready
//** Send task to task manager
zmsg_send(&msg, self->pipe);
} else { //** Otherwise put it on waiting list
zlist_push(self->data, zmsg_dup(msg));
}
} else if (zframe_streq(command, RRWRK_HEARTBEAT)) {
; //** Do nothing for heartbeat
} else if (zframe_streq(command, RRWRK_DISCONNECT)) {
rrwrk_connect_to_broker(self);
} else {
log_printf(0, "E: invalid input message\n");
}
zframe_destroy(&command);
zmsg_destroy(&msg);
} else if ((zclock_time() - self->heartbeat) > self->last_heartbeat) {
if(--self->liveness == 0) {
rrwrk_print(self);
log_printf(0, "W: Disconnected from broker - retrying ...\n");
rrwrk_print(self);
zclock_sleep(self->reconnect);
rrwrk_connect_to_broker(self);
}
}
if (items[1].revents & ZMQ_POLLIN) { //** Data from pipe is ready
zmsg_t *output = zmsg_recv(self->pipe);
assert(zmsg_size(output) == 3); //** UUID + SOURCE + DATA
self->total_finished++;
zmsg_t *reply = zmsg_new();
//** Adds UUID + SOURCE to reply message
zframe_t *uuid = zframe_dup(zmsg_first(output));
zframe_t *source = zframe_dup(zmsg_next(output));
zmsg_add(reply, uuid);
zmsg_add(reply, source);
//** Sends reply to broker
rrwrk_send_to_broker(self, RRWRK_REPLY, reply);
//** Sends output to sinker
//zmsg_send(&output, self->sender);
rrwrk_send_to_sinker(self, RRWRK_OUTPUT, output);
zmsg_destroy(&output);
zmsg_destroy(&reply);
}
//** Dispatch task if any
while (true) {
zmq_pollitem_t pipe_write = {self->pipe, 0, ZMQ_POLLOUT, 0};
zmq_poll(&pipe_write, 1, 0);
if ((pipe_write.revents & ZMQ_POLLOUT) && (zlist_size(self->data))) {
zmsg_t* data = (zmsg_t *)zlist_pop(self->data);
zmsg_send(&data, self->pipe);
printf("Dispatched one task.\n");
} else
break;
}
//** Send HEARTBEAT if it's time
if (zclock_time() > self->heartbeat_at) {
rrwrk_print(self);
rrwrk_send_to_broker(self, RRWRK_HEARTBEAT, NULL);
self->heartbeat_at = zclock_time() + self->heartbeat;
}
}
if (zctx_interrupted)
log_printf(0, "W: interrupt received. Killing worker...\n");
return -1;
}
void
zlist_test (bool verbose)
{
printf (" * zlist: ");
// @selftest
zlist_t *list = zlist_new ();
assert (list);
assert (zlist_size (list) == 0);
// Three items we'll use as test data
// List items are void *, not particularly strings
char *cheese = "boursin";
char *bread = "baguette";
char *wine = "bordeaux";
zlist_append (list, cheese);
assert (zlist_size (list) == 1);
assert ( zlist_exists (list, cheese));
assert (!zlist_exists (list, bread));
assert (!zlist_exists (list, wine));
zlist_append (list, bread);
assert (zlist_size (list) == 2);
assert ( zlist_exists (list, cheese));
assert ( zlist_exists (list, bread));
assert (!zlist_exists (list, wine));
zlist_append (list, wine);
assert (zlist_size (list) == 3);
assert ( zlist_exists (list, cheese));
assert ( zlist_exists (list, bread));
assert ( zlist_exists (list, wine));
assert (zlist_head (list) == cheese);
assert (zlist_next (list) == cheese);
assert (zlist_first (list) == cheese);
assert (zlist_tail (list) == wine);
assert (zlist_next (list) == bread);
assert (zlist_first (list) == cheese);
assert (zlist_next (list) == bread);
assert (zlist_next (list) == wine);
assert (zlist_next (list) == NULL);
// After we reach end of list, next wraps around
assert (zlist_next (list) == cheese);
assert (zlist_size (list) == 3);
zlist_remove (list, wine);
assert (zlist_size (list) == 2);
assert (zlist_first (list) == cheese);
zlist_remove (list, cheese);
assert (zlist_size (list) == 1);
assert (zlist_first (list) == bread);
zlist_remove (list, bread);
assert (zlist_size (list) == 0);
zlist_append (list, cheese);
zlist_append (list, bread);
assert (zlist_last (list) == bread);
zlist_remove (list, bread);
assert (zlist_last (list) == cheese);
zlist_remove (list, cheese);
assert (zlist_last (list) == NULL);
zlist_push (list, cheese);
assert (zlist_size (list) == 1);
assert (zlist_first (list) == cheese);
zlist_push (list, bread);
assert (zlist_size (list) == 2);
assert (zlist_first (list) == bread);
assert (zlist_item (list) == bread);
zlist_append (list, wine);
assert (zlist_size (list) == 3);
assert (zlist_first (list) == bread);
zlist_t *sub_list = zlist_dup (list);
assert (sub_list);
assert (zlist_size (sub_list) == 3);
zlist_sort (list, s_compare);
char *item;
item = (char *) zlist_pop (list);
assert (item == bread);
item = (char *) zlist_pop (list);
assert (item == wine);
item = (char *) zlist_pop (list);
assert (item == cheese);
assert (zlist_size (list) == 0);
assert (zlist_size (sub_list) == 3);
zlist_push (list, sub_list);
zlist_t *sub_list_2 = zlist_dup (sub_list);
zlist_append (list, sub_list_2);
assert (zlist_freefn (list, sub_list, &s_zlist_free, false) == sub_list);
assert (zlist_freefn (list, sub_list_2, &s_zlist_free, true) == sub_list_2);
zlist_destroy (&list);
// Test autofree functionality
list = zlist_new ();
assert (list);
zlist_autofree (list);
// Set equals function otherwise equals will not work as autofree copies strings
zlist_comparefn (list, s_compare);
zlist_push (list, bread);
zlist_append (list, cheese);
assert (zlist_size (list) == 2);
zlist_append (list, wine);
assert (zlist_exists (list, wine));
zlist_remove (list, wine);
assert (!zlist_exists (list, wine));
assert (streq ((const char *) zlist_first (list), bread));
item = (char *) zlist_pop (list);
assert (streq (item, bread));
free (item);
item = (char *) zlist_pop (list);
assert (streq (item, cheese));
free (item);
zlist_destroy (&list);
assert (list == NULL);
// @end
printf ("OK\n");
}
void
zlist_test (int verbose)
{
printf (" * zlist: ");
// @selftest
zlist_t *list = zlist_new ();
assert (list);
assert (zlist_size (list) == 0);
// Three items we'll use as test data
// List items are void *, not particularly strings
char *cheese = "boursin";
char *bread = "baguette";
char *wine = "bordeaux";
zlist_append (list, cheese);
assert (zlist_size (list) == 1);
zlist_append (list, bread);
assert (zlist_size (list) == 2);
zlist_append (list, wine);
assert (zlist_size (list) == 3);
assert (zlist_head (list) == cheese);
assert (zlist_next (list) == cheese);
assert (zlist_first (list) == cheese);
assert (zlist_tail (list) == wine);
assert (zlist_next (list) == bread);
assert (zlist_first (list) == cheese);
assert (zlist_next (list) == bread);
assert (zlist_next (list) == wine);
assert (zlist_next (list) == NULL);
// After we reach end of list, next wraps around
assert (zlist_next (list) == cheese);
assert (zlist_size (list) == 3);
zlist_remove (list, wine);
assert (zlist_size (list) == 2);
assert (zlist_first (list) == cheese);
zlist_remove (list, cheese);
assert (zlist_size (list) == 1);
assert (zlist_first (list) == bread);
zlist_remove (list, bread);
assert (zlist_size (list) == 0);
zlist_append (list, cheese);
zlist_append (list, bread);
assert (zlist_last (list) == bread);
zlist_remove (list, bread);
assert (zlist_last (list) == cheese);
zlist_remove (list, cheese);
assert (zlist_last (list) == NULL);
zlist_push (list, cheese);
assert (zlist_size (list) == 1);
assert (zlist_first (list) == cheese);
zlist_push (list, bread);
assert (zlist_size (list) == 2);
assert (zlist_first (list) == bread);
zlist_append (list, wine);
assert (zlist_size (list) == 3);
assert (zlist_first (list) == bread);
zlist_sort (list, s_compare);
char *item;
item = (char *) zlist_pop (list);
assert (item == bread);
item = (char *) zlist_pop (list);
assert (item == wine);
item = (char *) zlist_pop (list);
assert (item == cheese);
assert (zlist_size (list) == 0);
// Destructor should be safe to call twice
zlist_destroy (&list);
zlist_destroy (&list);
assert (list == NULL);
// @end
printf ("OK\n");
}
static void process_arguments(int argc, char * const *argv)
{
char c;
char *v;
int longindex = 0;
opterr = 0;
static struct option long_options[] = {
{ "config", required_argument, 0, 'c' },
{ "decompressors", required_argument, 0, 's' },
{ "device-id", required_argument, 0, 'd' },
{ "help", no_argument, 0, 0 },
{ "hosts", required_argument, 0, 'h' },
{ "input-port", required_argument, 0, 'p' },
{ "io-threads", required_argument, 0, 'i' },
{ "output-port", required_argument, 0, 'P' },
{ "quiet", no_argument, 0, 'q' },
{ "rcv-hwm", required_argument, 0, 'R' },
{ "snd-hwm", required_argument, 0, 'S' },
{ "subscribe", required_argument, 0, 'e' },
{ "verbose", no_argument, 0, 'v' },
{ 0, 0, 0, 0 }
};
while ((c = getopt_long(argc, argv, "vqd:p:P:R:S:c:e:i:s:h:", long_options, &longindex)) != -1) {
switch (c) {
case 'v':
if (verbose)
debug= true;
else
verbose = true;
break;
case 'q':
quiet = true;
break;
case 'e':
subscriptions = split_delimited_string(optarg);
break;
case 'd':
msg_meta.device_number = atoi(optarg);
break;
case 'p':
pull_port = atoi(optarg);
break;
case 'P':
pub_port = atoi(optarg);
break;
case 'c':
config_file_name = optarg;
break;
case 'i':
io_threads = atoi(optarg);
if (io_threads == 0) {
printf("[E] invalid io-threads value: must be greater than 0\n");
exit(1);
}
break;
case 's':
num_compressors = atoi(optarg);
if (num_compressors == 0) {
printf("[E] invalid number of compressors: must be greater than 0\n");
exit(1);
}
if (num_compressors > MAX_COMPRESSORS) {
printf("[E] invalid number of compressors: must be less than %d\n", MAX_COMPRESSORS+1);
exit(1);
}
break;
case 'h':
hosts = split_delimited_string(optarg);
if (hosts == NULL || zlist_size(hosts) == 0) {
printf("[E] must specifiy at least one device to connect to\n");
exit(1);
}
break;
case 'R':
rcv_hwm = atoi(optarg);
break;
case 'S':
snd_hwm = atoi(optarg);
break;
case 0:
print_usage(argv);
exit(0);
break;
case '?':
if (strchr("depcish", optopt))
fprintf(stderr, "option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf(stderr, "unknown option `-%c'.\n", optopt);
else
fprintf(stderr, "unknown option character `\\x%x'.\n", optopt);
print_usage(argv);
exit(1);
default:
fprintf(stderr, "BUG: can't process option -%c\n", c);
exit(1);
}
}
if (hosts == NULL) {
hosts = split_delimited_string(getenv("LOGJAM_DEVICES"));
if (hosts == NULL)
hosts = zlist_new();
if (zlist_size(hosts) == 0)
zlist_push(hosts, strdup("localhost"));
}
augment_zmq_connection_specs(&hosts, pull_port);
if (subscriptions == NULL)
subscriptions = split_delimited_string(getenv("LOGJAM_SUBSCRIPTIONS"));
if (rcv_hwm == -1) {
if (( v = getenv("LOGJAM_RCV_HWM") ))
rcv_hwm = atoi(v);
else
rcv_hwm = DEFAULT_RCV_HWM;
}
if (snd_hwm == -1) {
if (( v = getenv("LOGJAM_SND_HWM") ))
snd_hwm = atoi(v);
else
snd_hwm = DEFAULT_SND_HWM;
}
}
