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");
}
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 int
zyre_node_start (zyre_node_t *self)
{
// If application didn't bind explicitly, we grab an ephemeral port
// on all available network interfaces. This is orthogonal to
// beaconing, since we can connect to other peers and they will
// gossip our endpoint to others.
if (!self->bound) {
self->port = zsock_bind (self->inbox, "tcp://*:*");
if (self->port < 0)
return 1; // Could not get new port to bind to?
self->bound = true;
}
// Start UDP beaconing, if the application didn't disable it
if (self->beacon_port) {
assert (!self->beacon);
self->beacon = zbeacon_new (NULL, self->beacon_port);
if (!self->beacon)
return 1; // Not possible to start beacon
if (self->interval)
zbeacon_set_interval (self->beacon, self->interval);
zpoller_add (self->poller, zbeacon_socket (self->beacon));
// 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);
zbeacon_noecho (self->beacon);
zbeacon_publish (self->beacon, (byte *) &beacon, sizeof (beacon_t));
zbeacon_subscribe (self->beacon, (byte *) "ZRE", 3);
// Our own host endpoint is provided by the beacon
assert (!self->endpoint);
self->endpoint = zsys_sprintf ("tcp://%s:%d",
zbeacon_hostname (self->beacon), self->port);
}
else
if (!self->endpoint) {
char *hostname = zsys_hostname ();
self->endpoint = zsys_sprintf ("tcp://%s:%d", hostname, self->port);
zstr_free (&hostname);
}
// Start polling on inbox
zpoller_add (self->poller, self->inbox);
return 0;
}
static void
zyre_node_stop (zyre_node_t *self)
{
// 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 = 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
}
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");
}
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
zyre_node_start (zyre_node_t *self)
{
// 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);
zbeacon_noecho (self->beacon);
zbeacon_publish (self->beacon, (byte *) &beacon, sizeof (beacon_t));
zbeacon_subscribe (self->beacon, (byte *) "ZRE", 3);
// Our own host endpoint is provided by the beacon
self->host = zbeacon_hostname (self->beacon);
// Set up log instance
char sender [30]; // ipaddress:port endpoint
sprintf (sender, "%s:%d", self->host, self->port);
self->log = zyre_log_new (self->ctx, sender);
}
///
// Store UUID blob in target array
void QZuuid::exportNoConflict (byte *target)
{
zuuid_export (self, target);
}
void
zyre_node_actor (zsock_t *pipe, void *args)
{
// Create node instance to pass around
zyre_node_t *self = zyre_node_new (pipe, args);
if (!self) // Interrupted
return;
// Signal actor successfully initialized
zsock_signal (self->pipe, 0);
// Loop until the agent is terminated one way or another
int64_t reap_at = zclock_mono () + REAP_INTERVAL;
while (!self->terminated) {
// Start beacon as soon as we can
if (self->beacon && self->port <= 0) {
// Our hostname is provided by zbeacon
zsock_send(self->beacon, "si", "CONFIGURE", self->beacon_port);
char *hostname = zstr_recv(self->beacon);
// Is UDP broadcast interface available?
if (!streq(hostname, "")) {
if (zsys_ipv6())
self->port = zsock_bind(self->inbox, "tcp://%s%%%s:*", zsys_ipv6_address(), zsys_interface());
else
self->port = zsock_bind(self->inbox, "tcp://%s:*", hostname);
if (self->port > 0) {
assert(!self->endpoint); // If caller set this, we'd be using gossip
if (streq(zsys_interface(), "*")) {
char *hostname = zsys_hostname();
self->endpoint = zsys_sprintf("tcp://%s:%d", hostname, self->port);
zstr_free(&hostname);
}
else {
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);
// Start polling on inbox
zpoller_add(self->poller, self->inbox);
}
}
zstr_free(&hostname);
}
int timeout = (int) (reap_at - zclock_mono ());
if (timeout > REAP_INTERVAL)
timeout = REAP_INTERVAL;
else
if (timeout < 0)
timeout = 0;
zsock_t *which = (zsock_t *) zpoller_wait (self->poller, timeout);
if (which == self->pipe)
zyre_node_recv_api (self);
else
if (which == self->inbox)
zyre_node_recv_peer (self);
else
if (self->beacon
&& (void *) which == self->beacon)
zyre_node_recv_beacon (self);
else
if (self->gossip
&& (zactor_t *) which == self->gossip)
zyre_node_recv_gossip (self);
else
if (zpoller_terminated (self->poller))
break; // Interrupted, check before expired
else
if (zpoller_expired (self->poller)) {
if (zclock_mono () >= reap_at) {
void *item;
reap_at = zclock_mono () + REAP_INTERVAL;
// Ping all peers and reap any expired ones
for (item = zhash_first (self->peers); item != NULL;
item = zhash_next (self->peers))
zyre_node_ping_peer (zhash_cursor (self->peers), item, self);
}
}
}
zyre_node_destroy (&self);
}
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;
}
int
zproto_example_send (zproto_example_t *self, zsock_t *output)
{
assert (self);
assert (output);
if (zsock_type (output) == ZMQ_ROUTER)
zframe_send (&self->routing_id, output, ZFRAME_MORE + ZFRAME_REUSE);
size_t frame_size = 2 + 1; // Signature and message ID
switch (self->id) {
case ZPROTO_EXAMPLE_LOG:
frame_size += 2; // sequence
frame_size += 2; // version
frame_size += 1; // level
frame_size += 1; // event
frame_size += 2; // node
frame_size += 2; // peer
frame_size += 8; // time
frame_size += 1 + strlen (self->host);
frame_size += 4;
if (self->data)
frame_size += strlen (self->data);
break;
case ZPROTO_EXAMPLE_STRUCTURES:
frame_size += 2; // sequence
frame_size += 4; // Size is 4 octets
if (self->aliases) {
char *aliases = (char *) zlist_first (self->aliases);
while (aliases) {
frame_size += 4 + strlen (aliases);
aliases = (char *) zlist_next (self->aliases);
}
}
frame_size += 4; // Size is 4 octets
if (self->headers) {
self->headers_bytes = 0;
char *item = (char *) zhash_first (self->headers);
while (item) {
self->headers_bytes += 1 + strlen (zhash_cursor (self->headers));
self->headers_bytes += 4 + strlen (item);
item = (char *) zhash_next (self->headers);
}
}
frame_size += self->headers_bytes;
break;
case ZPROTO_EXAMPLE_BINARY:
frame_size += 2; // sequence
frame_size += 4; // flags
frame_size += 4; // Size is 4 octets
if (self->public_key)
frame_size += zchunk_size (self->public_key);
frame_size += ZUUID_LEN; // identifier
break;
case ZPROTO_EXAMPLE_TYPES:
frame_size += 2; // sequence
frame_size += 1 + strlen (self->client_forename);
frame_size += 1 + strlen (self->client_surname);
frame_size += 1 + strlen (self->client_mobile);
frame_size += 1 + strlen (self->client_email);
frame_size += 1 + strlen (self->supplier_forename);
frame_size += 1 + strlen (self->supplier_surname);
frame_size += 1 + strlen (self->supplier_mobile);
frame_size += 1 + strlen (self->supplier_email);
break;
}
// Now serialize message into the frame
zmq_msg_t frame;
zmq_msg_init_size (&frame, frame_size);
self->needle = (byte *) zmq_msg_data (&frame);
PUT_NUMBER2 (0xAAA0 | 0);
PUT_NUMBER1 (self->id);
bool have_content = false;
size_t nbr_frames = 1; // Total number of frames to send
switch (self->id) {
case ZPROTO_EXAMPLE_LOG:
PUT_NUMBER2 (self->sequence);
PUT_NUMBER2 (3);
PUT_NUMBER1 (self->level);
PUT_NUMBER1 (self->event);
PUT_NUMBER2 (self->node);
PUT_NUMBER2 (self->peer);
PUT_NUMBER8 (self->time);
PUT_STRING (self->host);
if (self->data) {
PUT_LONGSTR (self->data);
}
else
PUT_NUMBER4 (0); // Empty string
break;
case ZPROTO_EXAMPLE_STRUCTURES:
PUT_NUMBER2 (self->sequence);
if (self->aliases) {
PUT_NUMBER4 (zlist_size (self->aliases));
char *aliases = (char *) zlist_first (self->aliases);
while (aliases) {
PUT_LONGSTR (aliases);
aliases = (char *) zlist_next (self->aliases);
}
}
else
PUT_NUMBER4 (0); // Empty string array
if (self->headers) {
PUT_NUMBER4 (zhash_size (self->headers));
char *item = (char *) zhash_first (self->headers);
while (item) {
PUT_STRING (zhash_cursor (self->headers));
PUT_LONGSTR (item);
item = (char *) zhash_next (self->headers);
}
}
else
PUT_NUMBER4 (0); // Empty hash
break;
case ZPROTO_EXAMPLE_BINARY:
PUT_NUMBER2 (self->sequence);
PUT_OCTETS (self->flags, 4);
if (self->public_key) {
PUT_NUMBER4 (zchunk_size (self->public_key));
memcpy (self->needle,
zchunk_data (self->public_key),
zchunk_size (self->public_key));
self->needle += zchunk_size (self->public_key);
}
else
PUT_NUMBER4 (0); // Empty chunk
if (self->identifier)
zuuid_export (self->identifier, self->needle);
else
memset (self->needle, 0, ZUUID_LEN);
self->needle += ZUUID_LEN;
nbr_frames++;
nbr_frames += self->content? zmsg_size (self->content): 1;
have_content = true;
break;
case ZPROTO_EXAMPLE_TYPES:
PUT_NUMBER2 (self->sequence);
PUT_STRING (self->client_forename);
PUT_STRING (self->client_surname);
PUT_STRING (self->client_mobile);
PUT_STRING (self->client_email);
PUT_STRING (self->supplier_forename);
PUT_STRING (self->supplier_surname);
PUT_STRING (self->supplier_mobile);
PUT_STRING (self->supplier_email);
break;
}
// Now send the data frame
zmq_msg_send (&frame, zsock_resolve (output), --nbr_frames? ZMQ_SNDMORE: 0);
// Now send any frame fields, in order
if (self->id == ZPROTO_EXAMPLE_BINARY) {
// If address isn't set, send an empty frame
if (self->address)
zframe_send (&self->address, output, ZFRAME_REUSE + (--nbr_frames? ZFRAME_MORE: 0));
else
zmq_send (zsock_resolve (output), NULL, 0, (--nbr_frames? ZMQ_SNDMORE: 0));
}
// Now send the content if necessary
if (have_content) {
if (self->content) {
zframe_t *frame = zmsg_first (self->content);
while (frame) {
zframe_send (&frame, output, ZFRAME_REUSE + (--nbr_frames? ZFRAME_MORE: 0));
frame = zmsg_next (self->content);
}
}
else
zmq_send (zsock_resolve (output), NULL, 0, 0);
}
return 0;
}
int
xrap_traffic_send (xrap_traffic_t *self, zsock_t *output)
{
assert (self);
assert (output);
if (zsock_type (output) == ZMQ_ROUTER)
zframe_send (&self->routing_id, output, ZFRAME_MORE + ZFRAME_REUSE);
size_t frame_size = 2 + 1; // Signature and message ID
switch (self->id) {
case XRAP_TRAFFIC_CONNECTION_OPEN:
frame_size += 1 + strlen ("MALAMUTE");
frame_size += 2; // version
frame_size += 1 + strlen (self->address);
break;
case XRAP_TRAFFIC_XRAP_SEND:
frame_size += 4; // timeout
break;
case XRAP_TRAFFIC_XRAP_OFFER:
frame_size += 1 + strlen (self->route);
frame_size += 1 + strlen (self->method);
break;
case XRAP_TRAFFIC_XRAP_DELIVER:
frame_size += ZUUID_LEN; // sender
break;
case XRAP_TRAFFIC_OK:
frame_size += 2; // status_code
frame_size += 1 + strlen (self->status_reason);
break;
case XRAP_TRAFFIC_FAIL:
frame_size += 2; // status_code
frame_size += 1 + strlen (self->status_reason);
break;
case XRAP_TRAFFIC_ERROR:
frame_size += 2; // status_code
frame_size += 1 + strlen (self->status_reason);
break;
}
// Now serialize message into the frame
zmq_msg_t frame;
zmq_msg_init_size (&frame, frame_size);
self->needle = (byte *) zmq_msg_data (&frame);
PUT_NUMBER2 (0xAAA0 | 9);
PUT_NUMBER1 (self->id);
bool have_content = false;
size_t nbr_frames = 1; // Total number of frames to send
switch (self->id) {
case XRAP_TRAFFIC_CONNECTION_OPEN:
PUT_STRING ("MALAMUTE");
PUT_NUMBER2 (1);
PUT_STRING (self->address);
break;
case XRAP_TRAFFIC_XRAP_SEND:
PUT_NUMBER4 (self->timeout);
nbr_frames += self->content? zmsg_size (self->content): 1;
have_content = true;
break;
case XRAP_TRAFFIC_XRAP_OFFER:
PUT_STRING (self->route);
PUT_STRING (self->method);
break;
case XRAP_TRAFFIC_XRAP_DELIVER:
if (self->sender)
zuuid_export (self->sender, self->needle);
else
memset (self->needle, 0, ZUUID_LEN);
self->needle += ZUUID_LEN;
nbr_frames += self->content? zmsg_size (self->content): 1;
have_content = true;
break;
case XRAP_TRAFFIC_OK:
PUT_NUMBER2 (self->status_code);
PUT_STRING (self->status_reason);
break;
case XRAP_TRAFFIC_FAIL:
PUT_NUMBER2 (self->status_code);
PUT_STRING (self->status_reason);
break;
case XRAP_TRAFFIC_ERROR:
PUT_NUMBER2 (self->status_code);
PUT_STRING (self->status_reason);
break;
}
// Now send the data frame
zmq_msg_send (&frame, zsock_resolve (output), --nbr_frames? ZMQ_SNDMORE: 0);
// Now send the content if necessary
if (have_content) {
if (self->content) {
zframe_t *frame = zmsg_first (self->content);
while (frame) {
zframe_send (&frame, output, ZFRAME_REUSE + (--nbr_frames? ZFRAME_MORE: 0));
frame = zmsg_next (self->content);
}
}
else
zmq_send (zsock_resolve (output), NULL, 0, 0);
}
return 0;
}
