void zuuid_test (bool verbose) { printf (" * zuuid: "); // @selftest // Simple create/destroy test zuuid_t *uuid = zuuid_new (); assert (uuid); assert (zuuid_size (uuid) == 16); assert (strlen (zuuid_str (uuid)) == 32); zuuid_t *copy = zuuid_dup (uuid); assert (streq (zuuid_str (uuid), zuuid_str (copy))); // Check set/set_str/export methods const char *myuuid = "8CB3E9A9649B4BEF8DE225E9C2CEBB38"; zuuid_set_str (uuid, myuuid); assert (streq (zuuid_str (uuid), myuuid)); byte copy_uuid [16]; zuuid_export (uuid, copy_uuid); zuuid_set (uuid, copy_uuid); assert (streq (zuuid_str (uuid), myuuid)); zuuid_destroy (&uuid); zuuid_destroy (©); // @end printf ("OK\n"); }
/* Received response message from broker. * Look up the sender uuid in clients hash and deliver. * Responses for disconnected clients are silently discarded. */ static void response_cb (flux_t h, flux_msg_watcher_t *w, const flux_msg_t *msg, void *arg) { ctx_t *ctx = arg; char *uuid = NULL; client_t *c; flux_msg_t *cpy = flux_msg_copy (msg, true); if (!cpy) oom (); if (flux_msg_pop_route (cpy, &uuid) < 0) goto done; if (flux_msg_clear_route (cpy) < 0) goto done; c = zlist_first (ctx->clients); while (c) { if (!strcmp (uuid, zuuid_str (c->uuid))) { if (client_send_nocopy (c, &cpy) < 0) { /* FIXME handle errors */ flux_log (h, LOG_ERR, "%s: client_send %s: %s", __FUNCTION__, zuuid_str (c->uuid), strerror (errno)); errno = 0; } break; } c = zlist_next (ctx->clients); } if (uuid) free (uuid); done: flux_msg_destroy (cpy); }
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); zsock_send (self->beacon, "sbi", "PUBLISH", (byte *) &beacon, sizeof (beacon_t), self->interval); zclock_sleep (1); // Allow 1 msec for beacon to go out zpoller_remove (self->poller, self->beacon); zactor_destroy (&self->beacon); } // Stop polling on inbox zpoller_remove (self->poller, self->inbox); zstr_sendm (self->outbox, "STOP"); zstr_sendm (self->outbox, zuuid_str (self->uuid)); zstr_send (self->outbox, self->name); return 0; }
static zyre_peer_t * zyre_node_require_peer (zyre_node_t *self, zuuid_t *uuid, const char *endpoint) { assert (self); assert (endpoint); zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)); if (!peer) { // Purge any previous peer on same endpoint void *item; for (item = zhash_first (self->peers); item != NULL; item = zhash_next (self->peers)) zyre_node_purge_peer (zhash_cursor (self->peers), item, (char *) endpoint); peer = zyre_peer_new (self->peers, uuid); assert (peer); zyre_peer_set_origin (peer, self->name); zyre_peer_set_verbose (peer, self->verbose); zyre_peer_connect (peer, self->uuid, endpoint, self->expired_timeout); // Handshake discovery by sending HELLO as first message zlist_t *groups = zlist_dup (self->own_groups); zhash_t *headers = zhash_dup (self->headers); zre_msg_t *msg = zre_msg_new (ZRE_MSG_HELLO); zre_msg_set_endpoint (msg, self->endpoint); zre_msg_set_groups (msg, &groups); zre_msg_set_status (msg, self->status); zre_msg_set_name (msg, self->name); zre_msg_set_headers (msg, &headers); zyre_peer_send (peer, &msg); } return peer; }
static void register_new_client (client_t *self) { self->id = zuuid_new (); zhashx_update (self->server->clients, zuuid_str (self->id), self); xrap_traffic_set_status_code (self->message, XRAP_TRAFFIC_SUCCESS); }
static zyre_node_t * zyre_node_new (zsock_t *pipe, void *args) { zyre_node_t *self = (zyre_node_t *) zmalloc (sizeof (zyre_node_t)); self->inbox = zsock_new (ZMQ_ROUTER); if (self->inbox == NULL) { free (self); return NULL; // Could not create new socket } // Use ZMQ_ROUTER_HANDOVER so that when a peer disconnects and // then reconnects, the new client connection is treated as the // canonical one, and any old trailing commands are discarded. zsock_set_router_handover (self->inbox, 1); self->pipe = pipe; self->outbox = (zsock_t *) args; self->poller = zpoller_new (self->pipe, NULL); self->beacon_port = ZRE_DISCOVERY_PORT; self->interval = 0; // Use default self->uuid = zuuid_new (); self->peers = zhash_new (); self->peer_groups = zhash_new (); self->own_groups = zhash_new (); self->headers = zhash_new (); zhash_autofree (self->headers); // Default name for node is first 6 characters of UUID: // the shorter string is more readable in logs self->name = (char *) zmalloc (7); memcpy (self->name, zuuid_str (self->uuid), 6); return self; }
static void zyre_node_dump (zyre_node_t *self) { zsys_info ("zyre_node: dump state"); zsys_info (" - name=%s uuid=%s", self->name, zuuid_str (self->uuid)); zsys_info (" - endpoint=%s", self->endpoint); if (self->beacon_port) zsys_info (" - discovery=beacon port=%d interval=%zu", self->beacon_port, self->interval); else { zsys_info (" - discovery=gossip"); if (self->gossip_bind) zsys_info (" - bind endpoint=%s", self->gossip_bind); if (self->gossip_connect) zsys_info (" - connect endpoint=%s", self->gossip_connect); } zsys_info (" - headers=%zu:", zhash_size (self->headers)); zhash_foreach (self->headers, (zhash_foreach_fn *) zyre_node_log_pair, self); zsys_info (" - peers=%zu:", zhash_size (self->peers)); zhash_foreach (self->peers, (zhash_foreach_fn *) zyre_node_log_item, self); zsys_info (" - groups=%zu:", zhash_size (self->own_groups)); zhash_foreach (self->own_groups, (zhash_foreach_fn *) zyre_node_log_item, self); }
static zyre_peer_t * zyre_node_require_peer (zyre_node_t *self, zuuid_t *uuid, char *address, uint16_t port) { zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)); if (!peer) { // Purge any previous peer on same endpoint char endpoint [100]; snprintf (endpoint, 100, "tcp://%s:%hu", address, port); zhash_foreach (self->peers, zyre_node_purge_peer, endpoint); peer = zyre_peer_new (self->ctx, self->peers, uuid); zyre_peer_connect (peer, self->uuid, endpoint); // Handshake discovery by sending HELLO as first message zre_msg_t *msg = zre_msg_new (ZRE_MSG_HELLO); zre_msg_set_ipaddress (msg, self->host); zre_msg_set_mailbox (msg, self->port); zre_msg_set_groups (msg, zhash_keys (self->own_groups)); zre_msg_set_status (msg, self->status); zre_msg_set_headers (msg, zhash_dup (self->headers)); zyre_peer_send (peer, &msg); // Send new peer event to logger, if any zyre_log_info (self->log, ZRE_LOG_MSG_EVENT_ENTER, zyre_peer_endpoint (peer), endpoint); } return peer; }
zyre_peer_t * zyre_peer_new (zhash_t *container, zuuid_t *uuid) { zyre_peer_t *self = (zyre_peer_t *) zmalloc (sizeof (zyre_peer_t)); self->uuid = zuuid_dup (uuid); self->ready = false; self->connected = false; self->sent_sequence = 0; self->want_sequence = 0; // Insert into container if requested if (container) { int rc = zhash_insert (container, zuuid_str (self->uuid), self); assert (rc == 0); zhash_freefn (container, zuuid_str (self->uuid), s_delete_peer); } return self; }
static void zyre_node_dump (zyre_node_t *self) { void *item; zsys_info ("zyre_node: dump state"); zsys_info (" - name=%s uuid=%s", self->name, zuuid_str (self->uuid)); zsys_info (" - endpoint=%s", self->endpoint); if (self->beacon_port) zsys_info (" - discovery=beacon port=%d interval=%zu", self->beacon_port, self->interval); else { zsys_info (" - discovery=gossip"); if (self->gossip_bind) zsys_info (" - bind endpoint=%s", self->gossip_bind); if (self->gossip_connect) zsys_info (" - connect endpoint=%s", self->gossip_connect); } zsys_info (" - headers=%zu:", zhash_size (self->headers)); for (item = zhash_first (self->headers); item != NULL; item = zhash_next (self->headers)) zyre_node_log_pair (zhash_cursor (self->headers), item, self); zsys_info (" - peers=%zu:", zhash_size (self->peers)); for (item = zhash_first (self->peers); item != NULL; item = zhash_next (self->peers)) zyre_node_log_item (zhash_cursor (self->peers), item, self); zsys_info (" - own groups=%zu:", zlist_size (self->own_groups)); const char *group = (const char *) zlist_first (self->own_groups); while (group) { zsys_info (" - %s", group); group = (const char *) zlist_next (self->own_groups); } zsys_info (" - peer groups=%zu:", zhash_size (self->peer_groups)); zlist_t *groups = zhash_keys (self->peer_groups); group = (const char *) zlist_first (groups); while (group) { zsys_info (" - %s", group); zyre_group_t *rgroup = (zyre_group_t *) zhash_lookup (self->peer_groups, group); zlist_t *neighbors = zyre_group_peers (rgroup); char *neighbor = (char *) zlist_first (neighbors); while (neighbor) { zsys_info (" - %s", neighbor); neighbor = (char *) zlist_next (neighbors); } zlist_destroy (&neighbors); group = (const char *) zlist_next (groups); } zlist_destroy (&groups); }
static void *module_thread (void *arg) { module_t *p = arg; assert (p->magic == MODULE_MAGIC); sigset_t signal_set; int errnum; char *uri = xasprintf ("shmem://%s", zuuid_str (p->uuid)); char **av = NULL; char *rankstr = NULL; int ac; assert (p->zctx); /* Connect to broker socket, enable logging, register built-in services */ if (!(p->h = flux_open (uri, 0))) err_exit ("flux_open %s", uri); if (flux_opt_set (p->h, FLUX_OPT_ZEROMQ_CONTEXT, p->zctx, sizeof (p->zctx)) < 0) err_exit ("flux_opt_set ZEROMQ_CONTEXT"); rankstr = xasprintf ("%u", p->rank); if (flux_attr_fake (p->h, "rank", rankstr, FLUX_ATTRFLAG_IMMUTABLE) < 0) { err ("%s: error faking rank attribute", p->name); goto done; } flux_log_set_facility (p->h, p->name); modservice_register (p->h, p); /* Block all signals */ if (sigfillset (&signal_set) < 0) err_exit ("%s: sigfillset", p->name); if ((errnum = pthread_sigmask (SIG_BLOCK, &signal_set, NULL)) != 0) errn_exit (errnum, "pthread_sigmask"); /* Run the module's main(). */ ac = argz_count (p->argz, p->argz_len); av = xzmalloc (sizeof (av[0]) * (ac + 1)); argz_extract (p->argz, p->argz_len, av); if (p->main(p->h, ac, av) < 0) { err ("%s: mod_main returned error", p->name); goto done; } done: if (rankstr) free (rankstr); if (av) free (av); flux_close (p->h); p->h = NULL; return NULL; }
static void write_message_to_xrap_client (client_t *self) { zuuid_t *client_id = xrap_traffic_sender (self->message); assert (client_id); client_t *client = (client_t *) zhashx_lookup (self->server->clients, zuuid_str (client_id)); if (client) { // Save message for broker client->msg = zmsg_dup (xrap_traffic_content (self->message)); client->callee = NULL; engine_send_event (client, xrap_message_event); } }
book_t* shelf_add_book (shelf_t *self, const char *author, const char *title) { zuuid_t *uuid = zuuid_new (); const char *str_uuid = zuuid_str (uuid); const char* sql = "INSERT INTO book(id,author,title) VALUES($1,$2,$3);"; zpgutil_session_sql (self->session, sql); zpgutil_session_set (self->session, str_uuid); zpgutil_session_set (self->session, author); zpgutil_session_set (self->session, title); zpgutil_session_execute (self->session); zpgutil_session_commit (self->session); book_t *book = book_new (str_uuid,author,title); zuuid_destroy (&uuid); return book; }
void zuuid_test (bool verbose) { printf (" * zuuid: "); // @selftest // Simple create/destroy test assert (ZUUID_LEN == 16); assert (ZUUID_STR_LEN == 32); zuuid_t *uuid = zuuid_new (); assert (uuid); assert (zuuid_size (uuid) == ZUUID_LEN); assert (strlen (zuuid_str (uuid)) == ZUUID_STR_LEN); zuuid_t *copy = zuuid_dup (uuid); assert (streq (zuuid_str (uuid), zuuid_str (copy))); // Check set/set_str/export methods const char *myuuid = "8CB3E9A9649B4BEF8DE225E9C2CEBB38"; const char *myuuid2 = "8CB3E9A9-649B-4BEF-8DE2-25E9C2CEBB38"; const char *myuuid3 = "{8CB3E9A9-649B-4BEF-8DE2-25E9C2CEBB38}"; const char *myuuid4 = "8CB3E9A9649B4BEF8DE225E9C2CEBB3838"; int rc = zuuid_set_str (uuid, myuuid); assert (rc == 0); assert (streq (zuuid_str (uuid), myuuid)); rc = zuuid_set_str (uuid, myuuid2); assert (rc == 0); assert (streq (zuuid_str (uuid), myuuid)); rc = zuuid_set_str (uuid, myuuid3); assert (rc == 0); assert (streq (zuuid_str (uuid), myuuid)); rc = zuuid_set_str (uuid, myuuid4); assert (rc == -1); byte copy_uuid [ZUUID_LEN]; zuuid_export (uuid, copy_uuid); zuuid_set (uuid, copy_uuid); assert (streq (zuuid_str (uuid), myuuid)); // Check the canonical string format assert (streq (zuuid_str_canonical (uuid), "8cb3e9a9-649b-4bef-8de2-25e9c2cebb38")); zuuid_destroy (&uuid); zuuid_destroy (©); // @end printf ("OK\n"); }
/* Received an event message from broker. * Find all subscribers and deliver. */ static void event_cb (flux_t h, flux_msg_watcher_t *w, const flux_msg_t *msg, void *arg) { ctx_t *ctx = arg; client_t *c; c = zlist_first (ctx->clients); while (c) { if (subscription_match (c, msg)) { if (client_send (c, msg) < 0) { /* FIXME handle errors */ flux_log (h, LOG_ERR, "%s: client_send %s: %s", __FUNCTION__, zuuid_str (c->uuid), strerror (errno)); errno = 0; } } c = zlist_next (ctx->clients); } }
static int zyre_node_recv_beacon (zyre_node_t *self) { // Get IP address and beacon of peer char *ipaddress = zstr_recv (zbeacon_socket (self->beacon)); zframe_t *frame = zframe_recv (zbeacon_socket (self->beacon)); // Ignore anything that isn't a valid beacon bool is_valid = true; beacon_t beacon; if (zframe_size (frame) == sizeof (beacon_t)) { memcpy (&beacon, zframe_data (frame), zframe_size (frame)); if (beacon.version != BEACON_VERSION) is_valid = false; } else is_valid = false; // Check that the peer, identified by its UUID, exists if (is_valid) { zuuid_t *uuid = zuuid_new (); zuuid_set (uuid, beacon.uuid); if (beacon.port) { char endpoint [30]; sprintf (endpoint, "tcp://%s:%d", ipaddress, ntohs (beacon.port)); zyre_peer_t *peer = zyre_node_require_peer (self, uuid, endpoint); zyre_peer_refresh (peer); } else { // Zero port means peer is going away; remove it if // we had any knowledge of it already zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup ( self->peers, zuuid_str (uuid)); if (peer) zyre_node_remove_peer (self, peer); } zuuid_destroy (&uuid); } zstr_free (&ipaddress); zframe_destroy (&frame); return 0; }
static void zyre_node_recv_beacon (zyre_node_t *self) { // Get IP address and beacon of peer char *ipaddress = zstr_recv (self->beacon); zframe_t *frame = zframe_recv (self->beacon); if (ipaddress == NULL) return; // Interrupted // Ignore anything that isn't a valid beacon beacon_t beacon; memset (&beacon, 0, sizeof (beacon_t)); if (zframe_size (frame) == sizeof (beacon_t)) memcpy (&beacon, zframe_data (frame), zframe_size (frame)); zframe_destroy (&frame); if (beacon.version != BEACON_VERSION) return; // Garbage beacon, ignore it zuuid_t *uuid = zuuid_new (); zuuid_set (uuid, beacon.uuid); if (beacon.port) { char endpoint [100]; const char *iface = zsys_interface (); if (zsys_ipv6 () && iface && !streq (iface, "") && !streq (iface, "*")) sprintf (endpoint, "tcp://%s%%%s:%d", ipaddress, iface, ntohs (beacon.port)); else sprintf (endpoint, "tcp://%s:%d", ipaddress, ntohs (beacon.port)); zyre_peer_t *peer = zyre_node_require_peer (self, uuid, endpoint); zyre_peer_refresh (peer, self->evasive_timeout, self->expired_timeout); } else { // Zero port means peer is going away; remove it if // we had any knowledge of it already zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup ( self->peers, zuuid_str (uuid)); if (peer) zyre_node_remove_peer (self, peer); } zuuid_destroy (&uuid); zstr_free (&ipaddress); }
static void disconnect_destroy (client_t *c, struct disconnect_notify *d) { flux_msg_t *msg; if (!(msg = flux_msg_create (FLUX_MSGTYPE_REQUEST))) goto done; if (flux_msg_set_topic (msg, d->topic) < 0) goto done; if (flux_msg_enable_route (msg) < 0) goto done; if (flux_msg_push_route (msg, zuuid_str (c->uuid)) < 0) goto done; if (flux_msg_set_nodeid (msg, d->nodeid, d->flags) < 0) goto done; (void)flux_send (c->ctx->h, msg, 0); done: flux_msg_destroy (msg); free (d->topic); free (d); }
static int zyre_node_start (zyre_node_t *self) { if (self->beacon_port) { // Start beacon discovery // ------------------------------------------------------------------ assert (!self->beacon); self->beacon = zactor_new (zbeacon, NULL); if (!self->beacon) return 1; // Not possible to start beacon if (self->verbose) zsock_send (self->beacon, "s", "VERBOSE"); } else { // Start gossip discovery // ------------------------------------------------------------------ // If application didn't set an endpoint explicitly, grab ephemeral // port on all available network interfaces. if (!self->endpoint) { const char *iface = zsys_interface (); if (streq (iface, "")) iface = "*"; self->port = zsock_bind (self->inbox, "tcp://%s:*", iface); assert (self->port > 0); // Die on bad interface or port exhaustion char *hostname = zsys_hostname (); self->endpoint = zsys_sprintf ("tcp://%s:%d", hostname, self->port); zstr_free (&hostname); } assert (self->gossip); zstr_sendx (self->gossip, "PUBLISH", zuuid_str (self->uuid), self->endpoint, NULL); // Start polling on zgossip zpoller_add (self->poller, self->gossip); // Start polling on inbox zpoller_add(self->poller, self->inbox); } return 0; }
static void zyre_node_dump (zyre_node_t *self) { fflush (stdout); printf ("************** zyre_node_dump *************************\n"); printf ("node id : %s\n", zuuid_str (self->uuid)); printf (" endpoint = %s\n", self->endpoint); printf (" headers [%zu] { \n", zhash_size (self->headers)); zhash_foreach (self->headers, zyre_node_hash_key_dump, self); printf (" }\n"); printf (" peers [%zu] {\n", zhash_size (self->peers)); zhash_foreach (self->peers, zyre_node_hash_key_dump, self); printf (" }\n"); printf (" own groups [%zu] { \n", zhash_size (self->own_groups)); zhash_foreach (self->own_groups, zyre_node_hash_key_dump, self); printf (" }\n"); printf (" peer groups [%zu] {\n", zhash_size (self->peer_groups)); zhash_foreach (self->peer_groups, zyre_node_hash_key_dump, self); printf (" }\n"); printf ("*******************************************************\n"); fflush (stdout); }
static void client_read_cb (flux_t h, flux_fd_watcher_t *w, int fd, int revents, void *arg) { client_t *c = arg; flux_msg_t *msg = NULL; int type; if (revents & FLUX_POLLERR) goto disconnect; if (!(revents & FLUX_POLLIN)) return; /* EPROTO, ECONNRESET are normal disconnect errors * EWOULDBLOCK, EAGAIN stores state in c->inbuf for continuation */ //flux_log (h, LOG_DEBUG, "recv: client ready"); if (!(msg = flux_msg_recvfd (c->fd, &c->inbuf))) { if (errno == EWOULDBLOCK || errno == EAGAIN) { //flux_log (h, LOG_DEBUG, "recv: client not ready"); return; } if (errno != ECONNRESET && errno != EPROTO) flux_log (h, LOG_ERR, "flux_msg_recvfd: %s", strerror (errno)); goto disconnect; } if (flux_msg_get_type (msg, &type) < 0) { flux_log (h, LOG_ERR, "flux_msg_get_type: %s", strerror (errno)); goto disconnect; } switch (type) { const char *name; subscription_t *sub; case FLUX_MSGTYPE_REQUEST: if (match_substr (msg, "api.event.subscribe.", &name)) { sub = subscription_create (h, FLUX_MSGTYPE_EVENT, name); if (zlist_append (c->subscriptions, sub) < 0) oom (); } else if (match_substr (msg, "api.event.unsubscribe.", &name)) { if ((sub = subscription_lookup (c, FLUX_MSGTYPE_EVENT, name))) zlist_remove (c->subscriptions, sub); } else { /* insert disconnect notifier before forwarding request */ if (c->disconnect_notify && disconnect_update (c, msg) < 0) { flux_log (h, LOG_ERR, "disconnect_update: %s", strerror (errno)); goto disconnect; } if (flux_msg_push_route (msg, zuuid_str (c->uuid)) < 0) oom (); /* FIXME */ if (flux_send (h, msg, 0) < 0) err ("%s: flux_send", __FUNCTION__); } break; case FLUX_MSGTYPE_EVENT: if (flux_send (h, msg, 0) < 0) err ("%s: flux_send", __FUNCTION__); break; default: flux_log (h, LOG_ERR, "drop unexpected %s", flux_msg_typestr (type)); break; } flux_msg_destroy (msg); return; disconnect: flux_msg_destroy (msg); zlist_remove (c->ctx->clients, c); client_destroy (c); }
static void zyre_node_recv_peer (zyre_node_t *self) { // Router socket tells us the identity of this peer zre_msg_t *msg = zre_msg_recv (self->inbox); if (!msg) return; // Interrupted // First frame is sender identity byte *peerid_data = zframe_data (zre_msg_routing_id (msg)); size_t peerid_size = zframe_size (zre_msg_routing_id (msg)); // Identity must be [1] followed by 16-byte UUID if (peerid_size != ZUUID_LEN + 1) { zre_msg_destroy (&msg); return; } zuuid_t *uuid = zuuid_new (); zuuid_set (uuid, peerid_data + 1); // On HELLO we may create the peer if it's unknown // On other commands the peer must already exist zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)); if (zre_msg_id (msg) == ZRE_MSG_HELLO) { if (peer) { // Remove fake peers if (zyre_peer_ready (peer)) { zyre_node_remove_peer (self, peer); assert (!(zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid))); } else if (streq (zyre_peer_endpoint (peer), self->endpoint)) { // We ignore HELLO, if peer has same endpoint as current node zre_msg_destroy (&msg); zuuid_destroy (&uuid); return; } } peer = zyre_node_require_peer (self, uuid, zre_msg_endpoint (msg)); assert (peer); zyre_peer_set_ready (peer, true); } // Ignore command if peer isn't ready if (peer == NULL || !zyre_peer_ready (peer)) { zre_msg_destroy (&msg); zuuid_destroy (&uuid); return; } if (zyre_peer_messages_lost (peer, msg)) { zsys_warning ("(%s) messages lost from %s", self->name, zyre_peer_name (peer)); zyre_node_remove_peer (self, peer); zre_msg_destroy (&msg); zuuid_destroy (&uuid); return; } // Now process each command if (zre_msg_id (msg) == ZRE_MSG_HELLO) { // Store properties from HELLO command into peer zyre_peer_set_name (peer, zre_msg_name (msg)); zyre_peer_set_headers (peer, zre_msg_headers (msg)); // Tell the caller about the peer zstr_sendm (self->outbox, "ENTER"); zstr_sendm (self->outbox, zyre_peer_identity (peer)); zstr_sendm (self->outbox, zyre_peer_name (peer)); zframe_t *headers = zhash_pack (zyre_peer_headers (peer)); zframe_send (&headers, self->outbox, ZFRAME_MORE); zstr_send (self->outbox, zre_msg_endpoint (msg)); if (self->verbose) zsys_info ("(%s) ENTER name=%s endpoint=%s", self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer)); // Join peer to listed groups const char *name = zre_msg_groups_first (msg); while (name) { zyre_node_join_peer_group (self, peer, name); name = zre_msg_groups_next (msg); } // Now take peer's status from HELLO, after joining groups zyre_peer_set_status (peer, zre_msg_status (msg)); } else if (zre_msg_id (msg) == ZRE_MSG_WHISPER) { // Pass up to caller API as WHISPER event zstr_sendm (self->outbox, "WHISPER"); zstr_sendm (self->outbox, zuuid_str (uuid)); zstr_sendm (self->outbox, zyre_peer_name (peer)); zmsg_t *content = zmsg_dup (zre_msg_content (msg)); zmsg_send (&content, self->outbox); } else if (zre_msg_id (msg) == ZRE_MSG_SHOUT) { // Pass up to caller as SHOUT event zstr_sendm (self->outbox, "SHOUT"); zstr_sendm (self->outbox, zuuid_str (uuid)); zstr_sendm (self->outbox, zyre_peer_name (peer)); zstr_sendm (self->outbox, zre_msg_group (msg)); zmsg_t *content = zmsg_dup (zre_msg_content (msg)); zmsg_send (&content, self->outbox); } else if (zre_msg_id (msg) == ZRE_MSG_PING) { zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING_OK); zyre_peer_send (peer, &msg); } else if (zre_msg_id (msg) == ZRE_MSG_JOIN) { zyre_node_join_peer_group (self, peer, zre_msg_group (msg)); assert (zre_msg_status (msg) == zyre_peer_status (peer)); } else if (zre_msg_id (msg) == ZRE_MSG_LEAVE) { zyre_node_leave_peer_group (self, peer, zre_msg_group (msg)); assert (zre_msg_status (msg) == zyre_peer_status (peer)); } zuuid_destroy (&uuid); zre_msg_destroy (&msg); // Activity from peer resets peer timers zyre_peer_refresh (peer, self->evasive_timeout, self->expired_timeout); }
static int zyre_node_start (zyre_node_t *self) { if (self->beacon_port) { // Start beacon discovery // ------------------------------------------------------------------ assert (!self->beacon); self->beacon = zactor_new (zbeacon, NULL); if (!self->beacon) return 1; // Not possible to start beacon if (self->verbose) zsock_send (self->beacon, "s", "VERBOSE"); // Our hostname is provided by zbeacon zsock_send (self->beacon, "si", "CONFIGURE", self->beacon_port); char *hostname = zstr_recv (self->beacon); if (streq (hostname, "")) return -1; // No UDP broadcast interface available self->port = zsock_bind (self->inbox, "tcp://%s:*", hostname); zstr_free (&hostname); assert (self->port > 0); // Die on bad interface or port exhaustion assert (!self->endpoint); // If caller set this, we'd be using gossip self->endpoint = strdup (zsock_endpoint (self->inbox)); // Set broadcast/listen beacon beacon_t beacon; beacon.protocol [0] = 'Z'; beacon.protocol [1] = 'R'; beacon.protocol [2] = 'E'; beacon.version = BEACON_VERSION; beacon.port = htons (self->port); zuuid_export (self->uuid, beacon.uuid); zsock_send (self->beacon, "sbi", "PUBLISH", (byte *) &beacon, sizeof (beacon_t), self->interval); zsock_send (self->beacon, "sb", "SUBSCRIBE", (byte *) "ZRE", 3); zpoller_add (self->poller, self->beacon); } else { // Start gossip discovery // ------------------------------------------------------------------ // If application didn't set an endpoint explicitly, grab ephemeral // port on all available network interfaces. if (!self->endpoint) { const char *iface = zsys_interface (); if (streq (iface, "")) iface = "*"; self->port = zsock_bind (self->inbox, "tcp://%s:*", iface); assert (self->port > 0); // Die on bad interface or port exhaustion char *hostname = zsys_hostname (); self->endpoint = zsys_sprintf ("tcp://%s:%d", hostname, self->port); zstr_free (&hostname); } assert (self->gossip); zstr_sendx (self->gossip, "PUBLISH", zuuid_str (self->uuid), self->endpoint, NULL); // Start polling on zgossip zpoller_add (self->poller, self->gossip); } // Start polling on inbox zpoller_add (self->poller, self->inbox); return 0; }
const char * zyre_peer_identity (zyre_peer_t *self) { assert (self); return zuuid_str (self->uuid); }
/* step */ void zyre_bridge_step(ubx_block_t *b) { struct zyre_bridge_info *inf = (struct zyre_bridge_info*) b->private_data; /* Read data from port */ ubx_port_t* port = inf->ports.zyre_out; assert(port != 0); char * tmp_str = (char*) malloc(inf->max_msg_length*sizeof(char*)); ubx_data_t msg; checktype(port->block->ni, port->in_type, "unsigned char", port->name, 1); msg.type = port->in_type; msg.len = inf->max_msg_length; msg.data = tmp_str; //msg.data = inf->msg_buffer; int counter = 0; while (counter < inf->max_send) { int read_bytes = __port_read(port, &msg); //printf("zyrebidge: read bytes: %d\n",read_bytes); //printf("step: read strlen: %lu\n",strlen((char*) msg.data)); if (read_bytes <= 0) { //printf("zyre_bridge: No data recieved from port\n"); free(tmp_str); return; } // printf("zyrebridge: read bytes: %d\n",read_bytes); // port_read returns byte array. Need to add 0 termination manually to the string. tmp_str[read_bytes] = '\0'; // create json object and... json_t *pl; json_error_t error; pl= json_loads(tmp_str,0,&error); if(!pl) { printf("Error parsing JSON payload! line %d: %s\n", error.line, error.text); json_decref(pl); free(tmp_str); return; } // printf("[zyrebidge] retrieving msg: %s\n", json_dumps(pl, JSON_ENCODE_ANY)); // ...check for its type and embed it into msg envelope json_t *new_msg; new_msg = json_object(); json_object_set(new_msg, "payload", pl); json_object_set(new_msg, "metamodel", json_string("SHERPA")); if(json_object_get(pl, "@worldmodeltype") == 0) { printf("[zyrebidge] retrieving msg: %s\n", json_dumps(pl, JSON_ENCODE_ANY)); printf("[zyrebidge] Error parsing RSG payload! @worldmodeltype is missing.\n"); json_decref(pl); free(tmp_str); return; } std::string tmp_type = json_string_value(json_object_get(pl, "@worldmodeltype")); //can segfault char *send_msg; for (int i=0; i < inf->output_type_list.size();i++) { if (tmp_type.compare(inf->output_type_list[i])) { // need to handle exception for updates generated from RSG due to local updates if (tmp_type.compare("RSGUpdate") == 0) { json_object_set(new_msg, "model", json_string("RSGUpdate")); json_object_set(new_msg, "type", json_string("RSGUpdate_global")); // If used with mediator, add send_request envelope ubx_data_t *dmy; dmy = ubx_config_get_data(b, "mediator"); int mediator; mediator = *(int*) dmy->data; if (mediator == 1) { zuuid_t *query_uuid = zuuid_new (); assert (query_uuid); json_t *recip = json_array(); assert((recip)&&(json_array_size(recip)==0)); send_msg = send_request(zuuid_str(query_uuid),zyre_uuid(inf->node),recip,1000,"send_remote",new_msg); } else { send_msg = json_dumps(new_msg, JSON_ENCODE_ANY); } } else { json_object_set(new_msg, "model", json_string(tmp_type.c_str())); json_object_set(new_msg, "type", json_string(tmp_type.c_str())); send_msg = json_dumps(new_msg, JSON_ENCODE_ANY); } } else { printf("[zyre_bridge] Unknown output type: %s!\n",tmp_type.c_str()); } } printf("[zyrebidge] sending msg: %s\n", send_msg); zyre_shouts(inf->node, inf->group, "%s", send_msg); counter++; json_decref(pl); json_decref(new_msg); } free(tmp_str); return; }
/// // Returns UUID as string const QString QZuuid::str () { const QString rv = QString (zuuid_str (self)); return rv; }
static void deregister_the_client (client_t *self) { zhashx_delete (self->server->clients, zuuid_str (self->id)); }
static int zyre_node_recv_peer (zyre_node_t *self) { // Router socket tells us the identity of this peer zre_msg_t *msg = zre_msg_recv (self->inbox); if (msg == NULL) return 0; // Interrupted // First frame is sender identity, holding binary UUID zuuid_t *uuid = zuuid_new (); zuuid_set (uuid, zframe_data (zre_msg_address (msg))); // On HELLO we may create the peer if it's unknown // On other commands the peer must already exist zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)); if (zre_msg_id (msg) == ZRE_MSG_HELLO) { peer = zyre_node_require_peer (self, uuid, zre_msg_ipaddress (msg), zre_msg_mailbox (msg)); assert (peer); zyre_peer_set_ready (peer, true); } // Ignore command if peer isn't ready if (peer == NULL || !zyre_peer_ready (peer)) { zre_msg_destroy (&msg); zuuid_destroy (&uuid); return 0; } if (!zyre_peer_check_message (peer, msg)) { zclock_log ("W: [%s] lost messages from %s", zuuid_str (self->uuid), zuuid_str (uuid)); assert (false); } // Now process each command if (zre_msg_id (msg) == ZRE_MSG_HELLO) { // Tell the caller about the peer zstr_sendm (self->pipe, "ENTER"); zstr_sendm (self->pipe, zuuid_str (uuid)); zframe_t *headers = zhash_pack (zre_msg_headers (msg)); zframe_send (&headers, self->pipe, 0); // Join peer to listed groups char *name = zre_msg_groups_first (msg); while (name) { zyre_node_join_peer_group (self, peer, name); name = zre_msg_groups_next (msg); } // Hello command holds latest status of peer zyre_peer_set_status (peer, zre_msg_status (msg)); // Store peer headers for future reference zyre_peer_set_headers (peer, zre_msg_headers (msg)); // If peer is a ZRE/LOG collector, connect to it char *collector = zre_msg_headers_string (msg, "X-ZRELOG", NULL); if (collector) zyre_log_connect (self->log, collector); } else if (zre_msg_id (msg) == ZRE_MSG_WHISPER) { // Pass up to caller API as WHISPER event zstr_sendm (self->pipe, "WHISPER"); zstr_sendm (self->pipe, zuuid_str (uuid)); zmsg_t *content = zmsg_dup (zre_msg_content (msg)); zmsg_send (&content, self->pipe); } else if (zre_msg_id (msg) == ZRE_MSG_SHOUT) { // Pass up to caller as SHOUT event zstr_sendm (self->pipe, "SHOUT"); zstr_sendm (self->pipe, zuuid_str (uuid)); zstr_sendm (self->pipe, zre_msg_group (msg)); zmsg_t *content = zmsg_dup (zre_msg_content (msg)); zmsg_send (&content, self->pipe); } else if (zre_msg_id (msg) == ZRE_MSG_PING) { zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING_OK); zyre_peer_send (peer, &msg); } else if (zre_msg_id (msg) == ZRE_MSG_JOIN) { zyre_node_join_peer_group (self, peer, zre_msg_group (msg)); assert (zre_msg_status (msg) == zyre_peer_status (peer)); } else if (zre_msg_id (msg) == ZRE_MSG_LEAVE) { zyre_node_leave_peer_group (self, peer, zre_msg_group (msg)); assert (zre_msg_status (msg) == zyre_peer_status (peer)); } zuuid_destroy (&uuid); zre_msg_destroy (&msg); // Activity from peer resets peer timers zyre_peer_refresh (peer); return 0; }
/// // Returns UUID as string const QString QmlZuuid::str () { return QString (zuuid_str (self)); };
static void zyre_node_recv_api (zyre_node_t *self) { // Get the whole message off the pipe in one go zmsg_t *request = zmsg_recv (self->pipe); if (!request) return; // Interrupted char *command = zmsg_popstr (request); if (streq (command, "UUID")) zstr_send (self->pipe, zuuid_str (self->uuid)); else if (streq (command, "NAME")) zstr_send (self->pipe, self->name); else if (streq (command, "SET NAME")) { free (self->name); self->name = zmsg_popstr (request); assert (self->name); } else if (streq (command, "SET HEADER")) { char *name = zmsg_popstr (request); char *value = zmsg_popstr (request); zhash_update (self->headers, name, value); zstr_free (&name); zstr_free (&value); } else if (streq (command, "SET VERBOSE")) self->verbose = true; else if (streq (command, "SET PORT")) { char *value = zmsg_popstr (request); self->beacon_port = atoi (value); zstr_free (&value); } else if (streq (command, "SET EVASIVE TIMEOUT")) { char *value = zmsg_popstr (request); self->evasive_timeout = atoi (value); zstr_free (&value); } else if (streq (command, "SET EXPIRED TIMEOUT")) { char *value = zmsg_popstr (request); self->expired_timeout = atoi (value); zstr_free (&value); } else if (streq (command, "SET INTERVAL")) { char *value = zmsg_popstr (request); self->interval = atol (value); zstr_free (&value); } else if (streq (command, "SET ENDPOINT")) { zyre_node_gossip_start (self); char *endpoint = zmsg_popstr (request); if (zsock_bind (self->inbox, "%s", endpoint) != -1) { zstr_free (&self->endpoint); self->endpoint = endpoint; zsock_signal (self->pipe, 0); } else { zstr_free (&endpoint); zsock_signal (self->pipe, 1); } } else if (streq (command, "GOSSIP BIND")) { zyre_node_gossip_start (self); zstr_free (&self->gossip_bind); self->gossip_bind = zmsg_popstr (request); zstr_sendx (self->gossip, "BIND", self->gossip_bind, NULL); } else if (streq (command, "GOSSIP CONNECT")) { zyre_node_gossip_start (self); zstr_free (&self->gossip_connect); self->gossip_connect = zmsg_popstr (request); zstr_sendx (self->gossip, "CONNECT", self->gossip_connect, NULL); } else if (streq (command, "START")) zsock_signal (self->pipe, zyre_node_start (self)); else if (streq (command, "STOP")) zsock_signal (self->pipe, zyre_node_stop (self)); else if (streq (command, "WHISPER")) { // Get peer to send message to char *identity = zmsg_popstr (request); zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, identity); // Send frame on out to peer's mailbox, drop message // if peer doesn't exist (may have been destroyed) if (peer) { zre_msg_t *msg = zre_msg_new (ZRE_MSG_WHISPER); zre_msg_set_content (msg, &request); zyre_peer_send (peer, &msg); } zstr_free (&identity); } else if (streq (command, "SHOUT")) { // Get group to send message to char *name = zmsg_popstr (request); zyre_group_t *group = (zyre_group_t *) zhash_lookup (self->peer_groups, name); if (group) { zre_msg_t *msg = zre_msg_new (ZRE_MSG_SHOUT); zre_msg_set_group (msg, name); zre_msg_set_content (msg, &request); zyre_group_send (group, &msg); } zstr_free (&name); } else if (streq (command, "JOIN")) { char *name = zmsg_popstr (request); if (!zlist_exists (self->own_groups, name)) { void *item; // Only send if we're not already in group zlist_append (self->own_groups, name); zre_msg_t *msg = zre_msg_new (ZRE_MSG_JOIN); zre_msg_set_group (msg, name); // Update status before sending command zre_msg_set_status (msg, ++(self->status)); for (item = zhash_first (self->peers); item != NULL; item = zhash_next (self->peers)) zyre_node_send_peer (zhash_cursor (self->peers), item, msg); zre_msg_destroy (&msg); if (self->verbose) zsys_info ("(%s) JOIN group=%s", self->name, name); } zstr_free (&name); } else if (streq (command, "LEAVE")) { char *name = zmsg_popstr (request); if (zlist_exists (self->own_groups, name)) { void *item; // Only send if we are actually in group zre_msg_t *msg = zre_msg_new (ZRE_MSG_LEAVE); zre_msg_set_group (msg, name); // Update status before sending command zre_msg_set_status (msg, ++(self->status)); for (item = zhash_first (self->peers); item != NULL; item = zhash_next (self->peers)) zyre_node_send_peer (zhash_cursor (self->peers), item, msg); zre_msg_destroy (&msg); zlist_remove (self->own_groups, name); if (self->verbose) zsys_info ("(%s) LEAVE group=%s", self->name, name); } zstr_free (&name); } else if (streq (command, "PEERS")) zsock_send (self->pipe, "p", zhash_keys (self->peers)); else if (streq (command, "GROUP PEERS")) { char *name = zmsg_popstr (request); zyre_group_t *group = (zyre_group_t *) zhash_lookup (self->peer_groups, name); if (group) zsock_send (self->pipe, "p", zyre_group_peers (group)); else zsock_send (self->pipe, "p", NULL); zstr_free (&name); } else if (streq (command, "PEER ENDPOINT")) { char *uuid = zmsg_popstr (request); zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, uuid); assert (peer); zsock_send (self->pipe, "s", zyre_peer_endpoint (peer)); zstr_free (&uuid); } else if (streq (command, "PEER NAME")) { char *uuid = zmsg_popstr (request); zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, uuid); assert (peer); zsock_send (self->pipe, "s", zyre_peer_name (peer)); zstr_free (&uuid); } else if (streq (command, "PEER HEADER")) { char *uuid = zmsg_popstr (request); char *key = zmsg_popstr (request); zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, uuid); if (!peer) zstr_send (self->pipe, ""); else zstr_send (self->pipe, zyre_peer_header (peer, key, NULL)); zstr_free (&uuid); zstr_free (&key); } else if (streq (command, "PEER GROUPS")) zsock_send (self->pipe, "p", zhash_keys (self->peer_groups)); else if (streq (command, "OWN GROUPS")) zsock_send (self->pipe, "p", zlist_dup (self->own_groups)); else if (streq (command, "DUMP")) zyre_node_dump (self); else if (streq (command, "$TERM")) self->terminated = true; else { zsys_error ("invalid command '%s'", command); assert (false); } zstr_free (&command); zmsg_destroy (&request); }