/* 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); }