/* Destroy an instance of the Device Information */
devio_err_e devio_destroy (devio_t **self_p)
{
assert (self_p);
if (*self_p) {
devio_t *self = *self_p;
/* Destroy children threads before proceeding */
_devio_destroy_smio_all (self);
/* Starting destructing by the last resource */
/* Notice that we destroy the worker first, as to
* unregister from broker as soon as possible to avoid
* loosing requests from clients */
zctx_destroy (&self->ctx);
disp_table_destroy (&self->disp_table_thsafe_ops);
zhash_destroy (&self->sm_io_h);
self->thsafe_server_ops = NULL;
llio_release (self->llio, NULL);
llio_destroy (&self->llio);
free (self->endpoint_broker);
free (self->name);
zpoller_destroy (&self->poller);
free (self->pipes);
free (self);
*self_p = NULL;
}
return DEVIO_SUCCESS;
}
static void
s_agent_task (void *args, zctx_t *ctx, void *pipe)
{
char *endpoint = zstr_recv (pipe);
assert (endpoint);
agent_t *self = s_agent_new (ctx, pipe, endpoint);
zpoller_t *poller = zpoller_new (self->pipe, self->socket, NULL);
while (!zctx_interrupted) {
// Poll on API pipe and on monitor socket
void *result = zpoller_wait (poller, -1);
if (result == NULL)
break; // Interrupted
else
if (result == self->pipe)
s_api_command (self);
else
if (result == self->socket)
s_socket_event (self);
if (self->terminated)
break;
}
zpoller_destroy (&poller);
s_agent_destroy (&self);
}
void
drops_agent_main (void *args, zctx_t *ctx, void *pipe)
{
// Create agent instance to pass around
s_agent_t *self = s_agent_new (ctx, pipe);
if (!self) // Interrupted
return;
zstr_send (self->pipe, "OK");
// These are the sockets we will monitor for activity
zpoller_t *poller = zpoller_new (
self->pipe, zyre_socket (self->zyre), NULL);
while (!zpoller_terminated (poller)) {
// Check directory once a second; this is a pretty nasty way of
// doing it, but portable and simple. Later I'd like to use file
// system monitoring library and get events back over a socket.
void *which = zpoller_wait (poller, 1000);
if (which == self->pipe)
s_recv_from_api (self);
else
if (which == zyre_socket (self->zyre))
s_recv_from_zyre (self);
if (self->terminated)
break;
s_check_directory (self);
}
zpoller_destroy (&poller);
s_agent_destroy (&self);
}
MessageProcessor::~MessageProcessor()
{
zpoller_remove(zmqPoller_, zmqSocket_);
zpoller_destroy(&zmqPoller_);
zactor_destroy(&zmqAuth_);
zsock_destroy(&zmqSocket_);
}
static bool
s_can_connect (void *server, void *client)
{
// We'll do each test on a new port number since otherwise we have to
// destroy and recreate the sockets each time.
static int port_nbr = 9000;
int rc = zsocket_bind (server, "tcp://*:%d", port_nbr);
assert (rc == port_nbr);
rc = zsocket_connect (client, "tcp://localhost:%d", port_nbr);
assert (rc == 0);
zpoller_t *poller = zpoller_new (client, NULL);
zstr_send (server, "Hello, World");
// Need up to half a second if running under Valgrind
bool success = zpoller_wait (poller, 500) == client;
if (success)
free (zstr_recv (client));
zpoller_destroy (&poller);
rc = zsocket_unbind (server, "tcp://*:%d", port_nbr);
assert (rc != -1);
rc = zsocket_disconnect (client, "tcp://localhost:%d", port_nbr);
assert (rc != -1);
port_nbr++;
return success;
}
// Checks whether client can connect to server
static bool
s_can_connect (zctx_t *ctx, void **server, void **client)
{
int port_nbr = zsocket_bind (*server, "tcp://127.0.0.1:*");
assert (port_nbr > 0);
int rc = zsocket_connect (*client, "tcp://127.0.0.1:%d", port_nbr);
assert (rc == 0);
// Give the connection time to fail if that's the plan
zclock_sleep (200);
// By default PUSH sockets block if there's no peer
zsock_set_sndtimeo (*server, 200);
zstr_send (*server, "Hello, World");
zpoller_t *poller = zpoller_new (*client, NULL);
bool success = (zpoller_wait (poller, 400) == *client);
zpoller_destroy (&poller);
zsocket_destroy (ctx, *client);
zsocket_destroy (ctx, *server);
*server = zsocket_new (ctx, ZMQ_PUSH);
assert (*server);
*client = zsocket_new (ctx, ZMQ_PULL);
assert (*client);
return success;
}
int
zhttp_client_wait (zhttp_client_t *self, int timeout) {
zpoller_t *poller = zpoller_new (self, NULL);
void* sock = zpoller_wait (poller, timeout);
if (sock) {
zpoller_destroy (&poller);
return 0;
}
if (zpoller_expired (poller))
errno = EAGAIN;
else
errno = ETERM;
zpoller_destroy (&poller);
return -1;
}
static void
s_stream_engine_destroy (stream_engine_t **self_p)
{
assert (self_p);
if (*self_p) {
stream_engine_t *self = *self_p;
zpoller_destroy (&self->poller);
zlistx_destroy (&self->selectors);
zsock_destroy (&self->msgpipe);
free (self);
*self_p = NULL;
}
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
zsock_destroy (&self->frontend);
zsock_destroy (&self->backend);
zsock_destroy (&self->capture);
zpoller_destroy (&self->poller);
free (self);
*self_p = NULL;
}
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
zpoller_destroy (&self->poller);
zframe_destroy (&self->transmit);
zframe_destroy (&self->filter);
zsys_udp_close (self->udpsock);
free (self);
*self_p = NULL;
}
}
static void
s_upstream_destroy (upstream_t **self_p)
{
assert (self_p);
if (*self_p) {
upstream_t *self = *self_p;
zpoller_destroy (&self->poller);
zsock_destroy (&self->push);
// Free object itself
free (self);
*self_p = NULL;
}
}
static void
s_alerts (
zsock_t *pipe,
void *args) {
const char *name = "ALERT";
mlm_client_t *cl = mlm_client_new ();
mlm_client_connect (cl, endpoint, 5000, __PRETTY_FUNCTION__);
mlm_client_set_producer (cl, stream);
zsock_t *msgpipe = mlm_client_msgpipe (cl);
zpoller_t *poller = zpoller_new (pipe, msgpipe, NULL);
char *alert_state = strdup ("NEW");
zsock_signal (pipe, 0);
while (!zsys_interrupted) {
zsock_t *which = zpoller_wait (poller, 1000);
if (!which) {
mlm_client_sendx (cl, "alert://upsonbattery@ups1", alert_state, NULL);
continue;
}
if (which == pipe)
break;
//which == msgpipe
zmsg_t *msg = mlm_client_recv (cl);
if (!streq (mlm_client_command (cl), "MAILBOX DELIVER"))
goto msg_destroy;
char *alert_name = zmsg_popstr (msg);
zstr_free (&alert_state);
alert_state = zmsg_popstr (msg);
zsys_info ("%s: Alert '%s' new state is '%s'", name, alert_name, alert_state);
zstr_free (&alert_name);
msg_destroy:
zmsg_destroy (&msg);
}
zstr_free (&alert_state);
zpoller_destroy (&poller);
mlm_client_destroy (&cl);
}
static void
someactor_destroy (someactor_t **self_p)
{
assert (self_p);
if (*self_p) {
someactor_t *self = *self_p;
// TODO: Free actor properties
// Free object itself
zpoller_destroy (&self->poller);
free (self);
*self_p = NULL;
}
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
#if defined (ZMQ_EVENT_ALL)
zmq_socket_monitor (self->monitored, NULL, 0);
#endif
zpoller_destroy (&self->poller);
zsock_destroy (&self->sink);
free (self);
*self_p = NULL;
}
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
zhash_destroy (&self->passwords);
zhash_destroy (&self->whitelist);
zhash_destroy (&self->blacklist);
zcertstore_destroy (&self->certstore);
zsock_destroy (&self->handler);
zpoller_destroy (&self->poller);
free (self);
*self_p = NULL;
}
}
void
zyre_node_engine (void *args, zctx_t *ctx, void *pipe)
{
// Create node instance to pass around
zyre_node_t *self = zyre_node_new (ctx, pipe);
if (!self) // Interrupted
return;
zsocket_signal (self->pipe);
uint64_t reap_at = zclock_time () + REAP_INTERVAL;
zpoller_t *poller = zpoller_new (
self->pipe, self->inbox, zbeacon_socket (self->beacon), NULL);
while (!zpoller_terminated (poller)) {
if (self->terminated)
break;
int timeout = (int) (reap_at - zclock_time ());
assert (timeout <= REAP_INTERVAL);
if (timeout < 0)
timeout = 0;
void *which = zpoller_wait (poller, timeout);
if (which == self->pipe)
zyre_node_recv_api (self);
else
if (which == self->inbox)
zyre_node_recv_peer (self);
else
if (which == zbeacon_socket (self->beacon))
zyre_node_recv_beacon (self);
else
if (zpoller_expired(poller)) {
if (zclock_time () >= reap_at) {
reap_at = zclock_time () + REAP_INTERVAL;
// Ping all peers and reap any expired ones
zhash_foreach (self->peers, zyre_node_ping_peer, self);
}
}
else
if (zpoller_terminated(poller))
break;
else
// This should never happen
assert(false);
}
zpoller_destroy (&poller);
zyre_node_destroy (&self);
}
void maltcp_ctx_destroy_poller(void *self, void **poller_p) {
maltcp_poller_data_t **self_p = (maltcp_poller_data_t **) poller_p;
assert(self_p);
if (self_p && *self_p) {
maltcp_poller_data_t *self = *self_p;
*self_p = NULL;
zpoller_destroy(&self->poller);
free(self->endpoints);
// mal_ctx and mal_poller must not be destroyed here
// but where they have been created.
free(self);
}
}
// Checks whether client can connect to server
static bool
s_can_connect (zctx_t *ctx, void **server, void **client)
{
int port_nbr = zsocket_bind (*server, "tcp://127.0.0.1:*");
assert (port_nbr > 0);
int rc = zsocket_connect (*client, "tcp://127.0.0.1:%d", port_nbr);
assert (rc == 0);
zstr_send (*server, "Hello, World");
zpoller_t *poller = zpoller_new (*client, NULL);
bool success = (zpoller_wait (poller, 200) == *client);
zpoller_destroy (&poller);
zsocket_destroy (ctx, *client);
zsocket_destroy (ctx, *server);
*server = zsocket_new (ctx, ZMQ_PUSH);
*client = zsocket_new (ctx, ZMQ_PULL);
return success;
}
static void run(bool verbose, bool diagnostic, bool proxy_log) {
hid_init();
zsys_set_logsender(LOG_PUB_ENDPOINT);
// zsys_set_logsystem(true);
twps_server_t *self = twps_new(verbose, proxy_log);
assert(self);
self->diagnostic = diagnostic;
zpoller_t *poller = zpoller_new(self->printer_store_sub, NULL);
while (!zctx_interrupted) {
void *which = zpoller_wait(poller, 200);
if (which == self->printer_store_sub) {
s_loop_handle_printer_store_sub(self);
}
}
zpoller_destroy(&poller);
twps_destroy(&self);
hid_exit();
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
zhashx_destroy (&self->passwords);
zhashx_destroy (&self->whitelist);
zhashx_destroy (&self->blacklist);
zcertstore_destroy (&self->certstore);
zpoller_destroy (&self->poller);
if (self->handler) {
zsock_unbind (self->handler, ZAP_ENDPOINT);
zsock_destroy (&self->handler);
}
free (self);
*self_p = NULL;
}
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
zsock_destroy (&self->frontend);
zsock_destroy (&self->backend);
zsock_destroy (&self->capture);
for (int index = 0; index < SOCKETS; index++) {
zstr_free (&self->domain [index]);
zstr_free (&self->public_key [index]);
zstr_free (&self->secret_key [index]);
}
zpoller_destroy (&self->poller);
free (self);
*self_p = NULL;
}
}
void
zyre_log_test (bool verbose)
{
printf (" * zyre_log: ");
// @selftest
zctx_t *ctx = zctx_new ();
// Get all incoming log messages
void *collector = zsocket_new (ctx, ZMQ_SUB);
zsocket_bind (collector, "tcp://127.0.0.1:5555");
zsocket_set_subscribe (collector, "");
// Create a log instance to send log messages
zyre_log_t *log = zyre_log_new (ctx, "this is me");
zyre_log_connect (log, "tcp://127.0.0.1:5555");
// Workaround for issue 270; give time for connect to
// happen and subscriptions to go to pub socket; 200
// msec should be enough for under valgrind on a slow PC
zpoller_t *poller = zpoller_new (collector, NULL);
zpoller_wait (poller, 200);
// Send some messages
zyre_log_info (log, ZRE_LOG_MSG_EVENT_JOIN, NULL, "this is you");
zyre_log_info (log, ZRE_LOG_MSG_EVENT_EXIT, "Pizza time", "this is you");
zyre_log_warning (log, "this is you", "Time flies like an %s", "arrow");
zyre_log_error (log, "this is you", "Fruit flies like a %s", "banana");
int count = 0;
while (count < 4) {
zre_log_msg_t *msg = zre_log_msg_recv (collector);
assert (msg);
if (verbose)
zre_log_msg_dump (msg);
zre_log_msg_destroy (&msg);
count++;
}
zpoller_destroy (&poller);
zyre_log_destroy (&log);
zctx_destroy (&ctx);
// @end
printf ("OK\n");
}
// Destroy the broker
void
broker_destroy (broker_t **self_p)
{
assert (self_p);
if (*self_p) {
broker_t *self = *self_p;
zsock_destroy (&self->contexts);
zsock_destroy (&self->executors);
zpoller_destroy (&self->poller);
// TODO: delete contents of list.
zlist_destroy (&self->executor_lb);
zlist_destroy (&self->backlog);
// Free object itself
free (self);
*self_p = NULL;
}
}
static void
zyre_node_destroy (zyre_node_t **self_p)
{
assert (self_p);
if (*self_p) {
zyre_node_t *self = *self_p;
zpoller_destroy (&self->poller);
zuuid_destroy (&self->uuid);
zhash_destroy (&self->peers);
zhash_destroy (&self->peer_groups);
zhash_destroy (&self->own_groups);
zhash_destroy (&self->headers);
zsock_destroy (&self->inbox);
zsock_destroy (&self->outbox);
zbeacon_destroy (&self->beacon);
zstr_free (&self->endpoint);
free (self->name);
free (self);
*self_p = NULL;
}
}
static int
zyre_node_stop (zyre_node_t *self)
{
if (self->beacon) {
// Stop broadcast/listen beacon
beacon_t beacon;
beacon.protocol [0] = 'Z';
beacon.protocol [1] = 'R';
beacon.protocol [2] = 'E';
beacon.version = BEACON_VERSION;
beacon.port = 0; // Zero means we're stopping
zuuid_export (self->uuid, beacon.uuid);
zbeacon_publish (self->beacon, (byte *) &beacon, sizeof (beacon_t));
zclock_sleep (1); // Allow 1 msec for beacon to go out
zbeacon_destroy (&self->beacon);
}
// Stop polling on inbox
zpoller_destroy (&self->poller);
self->poller = zpoller_new (self->pipe, NULL);
return 0;
}
static void
s_agent_task (void *args, zctx_t *ctx, void *pipe)
{
// Create agent instance as we start this task
agent_t *self = s_agent_new (ctx, pipe);
if (!self) // Interrupted
return;
zpoller_t *poller = zpoller_new (self->pipe, self->handler, NULL);
while (!zpoller_terminated (poller) && !self->terminated) {
void *which = zpoller_wait (poller, -1);
if (which == self->pipe)
s_agent_handle_pipe (self);
else
if (which == self->handler)
s_agent_authenticate (self);
}
// Done, free all agent resources
zpoller_destroy (&poller);
s_agent_destroy (&self);
}
// Checks whether client can connect to server
static bool
s_can_connect (zactor_t **proxy, zsock_t **faucet, zsock_t **sink, const char *frontend, const char *backend, bool verbose)
{
assert (frontend);
assert (*faucet);
int rc = zsock_connect (*faucet, "%s", frontend);
assert (rc == 0);
assert (backend);
assert (*sink);
rc = zsock_connect (*sink, "%s", backend);
assert (rc == 0);
zstr_send (*faucet, "Hello, World");
zpoller_t *poller = zpoller_new (*sink, NULL);
assert (poller);
bool success = (zpoller_wait (poller, 200) == *sink);
zpoller_destroy (&poller);
s_create_test_sockets (proxy, faucet, sink, verbose);
return success;
}
void killIPC()
{
terminated = true; // tell IPC actor to kill itself
if (actor)
zactor_destroy (&actor);
if (poller)
zpoller_destroy (&poller);
// Notify peers that this peer is shutting down. Provide
// a brief interval to ensure message is emitted.
if (node)
zyre_stop(node);
zclock_sleep(100);
zyre_destroy (&node);
actor = 0;
node = 0;
poller = 0;
}
zpoller_t *
zpoller_new (void *reader, ...)
{
zpoller_t *self = (zpoller_t *) zmalloc (sizeof (zpoller_t));
assert (self);
#ifdef ZMQ_HAVE_POLLER
self->zmq_poller = zmq_poller_new ();
assert (self->zmq_poller);
#else
self->reader_list = zlist_new ();
assert (self->reader_list);
#endif
va_list args;
va_start (args, reader);
while (reader) {
if (zpoller_add (self, reader)) {
zpoller_destroy (&self);
break;
}
reader = va_arg (args, void *);
}
va_end (args);
return self;
}
static void
node_actor (zsock_t *pipe, void *args)
{
zyre_t *node = zyre_new (NULL);
if (!node)
return; // Could not create new node
zyre_set_verbose (node);
zyre_set_endpoint (node, "inproc://%s", (char *) args);
free (args);
// Connect to test hub
zyre_gossip_connect (node, "inproc://zyre-hub");
zyre_start (node);
zsock_signal (pipe, 0); // Signal "ready" to caller
int counter = 0;
char *to_peer = NULL; // Either of these set,
char *to_group = NULL; // and we set a message
char *cookie = NULL;
zpoller_t *poller = zpoller_new (pipe, zyre_socket (node), NULL);
int64_t trigger = zclock_mono () + 1000;
while (true) {
void *which = zpoller_wait (poller, randof (1000));
if (!which)
break; // Interrupted
// $TERM from parent means exit; anything else is breach of
// contract so we should assert
if (which == pipe) {
char *command = zstr_recv (pipe);
assert (streq (command, "$TERM"));
zstr_free (&command);
break; // Finished
}
// Process an event from node
if (which == zyre_socket (node)) {
zmsg_t *incoming = zyre_recv (node);
if (!incoming)
break; // Interrupted
char *event = zmsg_popstr (incoming);
char *peer = zmsg_popstr (incoming);
char *name = zmsg_popstr (incoming);
if (streq (event, "ENTER"))
// Always say hello to new peer
to_peer = strdup (peer);
else
if (streq (event, "EXIT"))
// Always try talk to departed peer
to_peer = strdup (peer);
else
if (streq (event, "WHISPER")) {
// Send back response 1/2 the time
if (randof (2) == 0) {
to_peer = strdup (peer);
cookie = zmsg_popstr (incoming);
}
}
else
if (streq (event, "SHOUT")) {
to_peer = strdup (peer);
to_group = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
// Send peer response 1/3rd the time
if (randof (3) > 0) {
free (to_peer);
to_peer = NULL;
}
// Send group response 1/3rd the time
if (randof (3) > 0) {
free (to_group);
to_group = NULL;
}
}
else
if (streq (event, "JOIN")) {
char *group = zmsg_popstr (incoming);
printf ("I: %s joined %s\n", name, group);
free (group);
}
else
if (streq (event, "LEAVE")) {
char *group = zmsg_popstr (incoming);
printf ("I: %s left %s\n", name, group);
free (group);
}
free (event);
free (peer);
free (name);
zmsg_destroy (&incoming);
// Send outgoing messages if needed
if (to_peer) {
zyre_whispers (node, to_peer, "%d", counter++);
free (to_peer);
to_peer = NULL;
}
if (to_group) {
zyre_shouts (node, to_group, "%d", counter++);
free (to_group);
to_group = NULL;
}
if (cookie) {
free (cookie);
cookie = NULL;
}
}
if (zclock_mono () >= trigger) {
trigger = zclock_mono () + 1000;
char group [10];
sprintf (group, "GROUP%03d", randof (MAX_GROUP));
if (randof (4) == 0)
zyre_join (node, group);
else
if (randof (3) == 0)
zyre_leave (node, group);
}
}
zpoller_destroy (&poller);
zyre_destroy (&node);
}
