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 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 dump_increments_hash(zhash_t *increments_hash)
{
increments_t *increments = zhash_first(increments_hash);
while (increments) {
const char *action = zhash_cursor(increments_hash);
dump_increments(action, increments);
increments = zhash_next(increments_hash);
}
}
// Looks at the current state and launches the next trigger
static int handle_next_event (ctx_t *ctx)
{
zhash_t *timers;
sim_state_t *sim_state = ctx->sim_state;
int rc = 0;
// get the timer hashtable, make sure its full, and get a list of its keys
timers = sim_state->timers;
if (zhash_size (timers) < 1) {
flux_log (ctx->h, LOG_ERR, "timer hashtable has no elements");
return -1;
}
// Get the next occuring event time/module
double min_event_time = -1;
double *curr_event_time = NULL;
const char *mod_name = NULL, *curr_name = NULL;
for (curr_event_time = zhash_first (timers);
curr_event_time;
curr_event_time = zhash_next (timers)) {
curr_name = zhash_cursor (timers);
if (min_event_time < 0 ||
occurs_before (*curr_event_time, min_event_time) ||
breaks_tie (*curr_event_time, min_event_time, curr_name)) {
min_event_time = *curr_event_time;
mod_name = curr_name;
}
}
if (min_event_time < 0) {
return -1;
}
// advance time then send the trigger to the module with the next event
if (min_event_time > sim_state->sim_time) {
// flux_log (ctx->h, LOG_DEBUG, "Time was advanced from %f to %f while
// triggering the next event for %s",
// sim_state->sim_time, *min_event_time, mod_name);
sim_state->sim_time = min_event_time;
} else {
// flux_log (ctx->h, LOG_DEBUG, "Time was not advanced while triggering
// the next event for %s", mod_name);
}
flux_log (ctx->h,
LOG_DEBUG,
"Triggering %s. Curr sim time: %f",
mod_name,
sim_state->sim_time);
rc = send_trigger (ctx->h, mod_name, sim_state);
return rc;
}
void
zcert_fprint (zcert_t *self, FILE *file)
{
assert (self);
fprintf (file, "metadata\n");
char *value = (char *) zhash_first (self->metadata);
while (value) {
fprintf (file, " %s = \"%s\"\n",
zhash_cursor (self->metadata), value);
value = (char *) zhash_next (self->metadata);
}
fprintf (file, "curve\n");
fprintf (file, " public-key = \"%s\"\n", self->public_txt);
fprintf (file, " secret-key = \"%s\"\n", self->secret_txt);
}
void
zcert_print (zcert_t *self)
{
assert (self);
zsys_info ("zcert: metadata");
char *value = (char *) zhash_first (self->metadata);
while (value) {
zsys_info ("zcert: %s = \"%s\"",
zhash_cursor (self->metadata), value);
value = (char *) zhash_next (self->metadata);
}
zsys_info ("zcert: curve");
zsys_info ("zcert: public-key = \"%s\"", self->public_txt);
zsys_info ("zcert: secret-key = \"%s\"", self->secret_txt);
}
static void copy_new_state_data (ctx_t *ctx,
sim_state_t *curr_sim_state,
sim_state_t *reply_sim_state)
{
if (reply_sim_state->sim_time > curr_sim_state->sim_time) {
curr_sim_state->sim_time = reply_sim_state->sim_time;
}
void *item = NULL;
const char *key = NULL;
for (item = zhash_first (reply_sim_state->timers);
item;
item = zhash_next (reply_sim_state->timers)) {
key = zhash_cursor (reply_sim_state->timers);
check_for_new_timers (key, item, ctx);
}
}
int maltcp_ctx_connection_remove_socket(maltcp_ctx_t *self, int socket) {
clog_debug(maltcp_logger, "maltcp_ctx_connection_remove_socket(%d).\n", socket);
maltcp_ctx_connection_t *cnx_ptr = (maltcp_ctx_connection_t*) zhash_first(self->cnx_table);
while (cnx_ptr) {
if (cnx_ptr->socket == socket) {
// Close registered TCP connections
clog_debug(maltcp_logger, "maltcp_ctx_connection_remove_socket: close and remove socket.\n");
maltcp_ctx_socket_destroy(cnx_ptr);
zhash_delete(self->cnx_table, zhash_cursor(self->cnx_table));
// TODO: Should free the allocated string key and element structure.
return 0;
}
cnx_ptr = (maltcp_ctx_connection_t*) zhash_next(self->cnx_table);
}
clog_debug(maltcp_logger, "maltcp_ctx_connection_remove_socket: socket (%d) not found.\n", socket);
return 0;
}
static void
s_save_metadata_all (zcert_t *self)
{
zconfig_destroy (&self->config);
self->config = zconfig_new ("root", NULL);
zconfig_t *section = zconfig_new ("metadata", self->config);
char *value = (char *) zhash_first (self->metadata);
while (value) {
zconfig_t *item = zconfig_new (zhash_cursor (self->metadata), section);
zconfig_set_value (item, "%s", value);
value = (char *) zhash_next (self->metadata);
}
char *timestr = zclock_timestr ();
zconfig_set_comment (self->config,
" **** Generated on %s by CZMQ ****", timestr);
zstr_free (×tr);
}
static void
zyre_node_remove_peer (zyre_node_t *self, zyre_peer_t *peer)
{
void *item;
// Tell the calling application the peer has gone
zstr_sendm (self->outbox, "EXIT");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_send (self->outbox, zyre_peer_name (peer));
if (self->verbose)
zsys_info ("(%s) EXIT name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
// Remove peer from any groups we've got it in
for (item = zhash_first (self->peer_groups); item != NULL;
item = zhash_next (self->peer_groups))
zyre_node_delete_peer (zhash_cursor (self->peer_groups), item, peer);
// To destroy peer, we remove from peers hash table
zhash_delete (self->peers, zyre_peer_identity (peer));
}
void
sprk_dataset_destroy (sprk_dataset_t **self_p)
{
assert (self_p);
if (*self_p) {
sprk_dataset_t *self = *self_p;
block_t *block = (block_t *) zhash_first (self->blocks);
while (block != NULL) {
block_destroy (&block);
zhash_delete (self->blocks, zhash_cursor (self->blocks));
block = (block_t *) zhash_next (self->blocks);
}
zhash_destroy (&self->blocks);
// Free object itself
free (self);
*self_p = NULL;
}
}
void
zyre_event_print (zyre_event_t *self)
{
zsys_info ("zyre_event:");
zsys_info (" - from name=%s uuid=%s",
zyre_event_peer_name (self),
zyre_event_peer_uuid (self));
zsys_info (" - type=%s", self->type);
if (streq (self->type, "ENTER")) {
void *item;
zsys_info (" - headers=%zu:", zhash_size (self->headers));
for (item = zhash_first (self->headers); item != NULL;
item = zhash_next (self->headers))
zyre_event_log_pair (zhash_cursor (self->headers), item, self);
zsys_info (" - address=%s", zyre_event_peer_addr (self));
}
else
if (streq (self->type, "JOIN")) {
zsys_info (" - group=%s", zyre_event_group (self));
}
else
if (streq (self->type, "LEAVE")) {
zsys_info (" - group=%s", zyre_event_group (self));
}
else
if (streq (self->type, "SHOUT")) {
zsys_info (" - message:");
zmsg_print (self->msg);
}
else
if (streq (self->type, "WHISPER")) {
zsys_info (" - message:");
zmsg_print (self->msg);
}
else
if (streq (self->type, "LEADER")) {
zsys_info (" - group=%s", zyre_event_group (self));
}
}
int
zring_insert (zring_t *self, const void *key, void *item)
{
assert (self);
assert (key);
assert (item);
if (!self->hash)
self->hash = zhash_new ();
if (!self->hash)
return -1;
// If item isn't already in dictionary, append to list and then
// store item node (which is in cursor) in dictionary
if (!zhash_lookup (self->hash, key)
&& !zring_append (self, item)
&& !zhash_insert (self->hash, key, self->cursor)) {
self->cursor->key = zhash_cursor (self->hash);
return 0;
}
else
return -1;
}
const char *
zargs_param_name (zargs_t *self) {
assert (self);
return (const char*) zhash_cursor (self->parameters);
}
void
zhash_test (bool verbose)
{
printf (" * zhash: ");
// @selftest
zhash_t *hash = zhash_new ();
assert (hash);
assert (zhash_size (hash) == 0);
assert (zhash_first (hash) == NULL);
assert (zhash_cursor (hash) == NULL);
// Insert some items
int rc;
rc = zhash_insert (hash, "DEADBEEF", "dead beef");
char *item = (char *) zhash_first (hash);
assert (streq (zhash_cursor (hash), "DEADBEEF"));
assert (streq (item, "dead beef"));
assert (rc == 0);
rc = zhash_insert (hash, "ABADCAFE", "a bad cafe");
assert (rc == 0);
rc = zhash_insert (hash, "C0DEDBAD", "coded bad");
assert (rc == 0);
rc = zhash_insert (hash, "DEADF00D", "dead food");
assert (rc == 0);
assert (zhash_size (hash) == 4);
// Look for existing items
item = (char *) zhash_lookup (hash, "DEADBEEF");
assert (streq (item, "dead beef"));
item = (char *) zhash_lookup (hash, "ABADCAFE");
assert (streq (item, "a bad cafe"));
item = (char *) zhash_lookup (hash, "C0DEDBAD");
assert (streq (item, "coded bad"));
item = (char *) zhash_lookup (hash, "DEADF00D");
assert (streq (item, "dead food"));
// Look for non-existent items
item = (char *) zhash_lookup (hash, "foo");
assert (item == NULL);
// Try to insert duplicate items
rc = zhash_insert (hash, "DEADBEEF", "foo");
assert (rc == -1);
item = (char *) zhash_lookup (hash, "DEADBEEF");
assert (streq (item, "dead beef"));
// Some rename tests
// Valid rename, key is now LIVEBEEF
rc = zhash_rename (hash, "DEADBEEF", "LIVEBEEF");
assert (rc == 0);
item = (char *) zhash_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
// Trying to rename an unknown item to a non-existent key
rc = zhash_rename (hash, "WHATBEEF", "NONESUCH");
assert (rc == -1);
// Trying to rename an unknown item to an existing key
rc = zhash_rename (hash, "WHATBEEF", "LIVEBEEF");
assert (rc == -1);
item = (char *) zhash_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
// Trying to rename an existing item to another existing item
rc = zhash_rename (hash, "LIVEBEEF", "ABADCAFE");
assert (rc == -1);
item = (char *) zhash_lookup (hash, "LIVEBEEF");
assert (streq (item, "dead beef"));
item = (char *) zhash_lookup (hash, "ABADCAFE");
assert (streq (item, "a bad cafe"));
// Test keys method
zlist_t *keys = zhash_keys (hash);
assert (zlist_size (keys) == 4);
zlist_destroy (&keys);
// Test dup method
zhash_t *copy = zhash_dup (hash);
assert (zhash_size (copy) == 4);
item = (char *) zhash_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhash_destroy (©);
// Test pack/unpack methods
zframe_t *frame = zhash_pack (hash);
copy = zhash_unpack (frame);
zframe_destroy (&frame);
assert (zhash_size (copy) == 4);
item = (char *) zhash_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhash_destroy (©);
// Test save and load
zhash_comment (hash, "This is a test file");
zhash_comment (hash, "Created by %s", "czmq_selftest");
zhash_save (hash, ".cache");
copy = zhash_new ();
assert (copy);
zhash_load (copy, ".cache");
item = (char *) zhash_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhash_destroy (©);
zsys_file_delete (".cache");
// Delete a item
zhash_delete (hash, "LIVEBEEF");
item = (char *) zhash_lookup (hash, "LIVEBEEF");
assert (item == NULL);
assert (zhash_size (hash) == 3);
// Check that the queue is robust against random usage
struct {
char name [100];
bool exists;
} testset [200];
memset (testset, 0, sizeof (testset));
int testmax = 200, testnbr, iteration;
srandom ((unsigned) time (NULL));
for (iteration = 0; iteration < 25000; iteration++) {
testnbr = randof (testmax);
if (testset [testnbr].exists) {
item = (char *) zhash_lookup (hash, testset [testnbr].name);
assert (item);
zhash_delete (hash, testset [testnbr].name);
testset [testnbr].exists = false;
}
else {
sprintf (testset [testnbr].name, "%x-%x", rand (), rand ());
if (zhash_insert (hash, testset [testnbr].name, "") == 0)
testset [testnbr].exists = true;
}
}
// Test 10K lookups
for (iteration = 0; iteration < 10000; iteration++)
item = (char *) zhash_lookup (hash, "DEADBEEFABADCAFE");
// Destructor should be safe to call twice
zhash_destroy (&hash);
zhash_destroy (&hash);
assert (hash == NULL);
// Test autofree; automatically copies and frees string values
hash = zhash_new ();
assert (hash);
zhash_autofree (hash);
char value [255];
strcpy (value, "This is a string");
rc = zhash_insert (hash, "key1", value);
assert (rc == 0);
strcpy (value, "Inserting with the same key will fail");
rc = zhash_insert (hash, "key1", value);
assert (rc == -1);
strcpy (value, "Ring a ding ding");
rc = zhash_insert (hash, "key2", value);
assert (rc == 0);
assert (streq ((char *) zhash_lookup (hash, "key1"), "This is a string"));
assert (streq ((char *) zhash_lookup (hash, "key2"), "Ring a ding ding"));
zhash_destroy (&hash);
// @end
printf ("OK\n");
}
void
fmq_msg_test (bool verbose)
{
printf (" * fmq_msg:");
if (verbose)
printf ("\n");
// @selftest
// Simple create/destroy test
fmq_msg_t *self = fmq_msg_new ();
assert (self);
fmq_msg_destroy (&self);
// Create pair of sockets we can send through
// We must bind before connect if we wish to remain compatible with ZeroMQ < v4
zsock_t *output = zsock_new (ZMQ_DEALER);
assert (output);
int rc = zsock_bind (output, "inproc://selftest-fmq_msg");
assert (rc == 0);
zsock_t *input = zsock_new (ZMQ_ROUTER);
assert (input);
rc = zsock_connect (input, "inproc://selftest-fmq_msg");
assert (rc == 0);
// Encode/send/decode and verify each message type
int instance;
self = fmq_msg_new ();
fmq_msg_set_id (self, FMQ_MSG_OHAI);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_OHAI_OK);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_ICANHAZ);
fmq_msg_set_path (self, "Life is short but Now lasts for ever");
zhash_t *icanhaz_options = zhash_new ();
zhash_insert (icanhaz_options, "Name", "Brutus");
fmq_msg_set_options (self, &icanhaz_options);
zhash_t *icanhaz_cache = zhash_new ();
zhash_insert (icanhaz_cache, "Name", "Brutus");
fmq_msg_set_cache (self, &icanhaz_cache);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
assert (streq (fmq_msg_path (self), "Life is short but Now lasts for ever"));
zhash_t *options = fmq_msg_get_options (self);
assert (zhash_size (options) == 2);
assert (streq ((char *) zhash_first (options), "Brutus"));
assert (streq ((char *) zhash_cursor (options), "Name"));
zhash_destroy (&options);
if (instance == 1)
zhash_destroy (&icanhaz_options);
zhash_t *cache = fmq_msg_get_cache (self);
assert (zhash_size (cache) == 2);
assert (streq ((char *) zhash_first (cache), "Brutus"));
assert (streq ((char *) zhash_cursor (cache), "Name"));
zhash_destroy (&cache);
if (instance == 1)
zhash_destroy (&icanhaz_cache);
}
fmq_msg_set_id (self, FMQ_MSG_ICANHAZ_OK);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_NOM);
fmq_msg_set_credit (self, 123);
fmq_msg_set_sequence (self, 123);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
assert (fmq_msg_credit (self) == 123);
assert (fmq_msg_sequence (self) == 123);
}
fmq_msg_set_id (self, FMQ_MSG_CHEEZBURGER);
fmq_msg_set_sequence (self, 123);
fmq_msg_set_operation (self, 123);
fmq_msg_set_filename (self, "Life is short but Now lasts for ever");
fmq_msg_set_offset (self, 123);
fmq_msg_set_eof (self, 123);
zhash_t *cheezburger_headers = zhash_new ();
zhash_insert (cheezburger_headers, "Name", "Brutus");
fmq_msg_set_headers (self, &cheezburger_headers);
zchunk_t *cheezburger_chunk = zchunk_new ("Captcha Diem", 12);
fmq_msg_set_chunk (self, &cheezburger_chunk);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
assert (fmq_msg_sequence (self) == 123);
assert (fmq_msg_operation (self) == 123);
assert (streq (fmq_msg_filename (self), "Life is short but Now lasts for ever"));
assert (fmq_msg_offset (self) == 123);
assert (fmq_msg_eof (self) == 123);
zhash_t *headers = fmq_msg_get_headers (self);
assert (zhash_size (headers) == 2);
assert (streq ((char *) zhash_first (headers), "Brutus"));
assert (streq ((char *) zhash_cursor (headers), "Name"));
zhash_destroy (&headers);
if (instance == 1)
zhash_destroy (&cheezburger_headers);
assert (memcmp (zchunk_data (fmq_msg_chunk (self)), "Captcha Diem", 12) == 0);
if (instance == 1)
zchunk_destroy (&cheezburger_chunk);
}
fmq_msg_set_id (self, FMQ_MSG_HUGZ);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_HUGZ_OK);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_KTHXBAI);
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
}
fmq_msg_set_id (self, FMQ_MSG_SRSLY);
fmq_msg_set_reason (self, "Life is short but Now lasts for ever");
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
assert (streq (fmq_msg_reason (self), "Life is short but Now lasts for ever"));
}
fmq_msg_set_id (self, FMQ_MSG_RTFM);
fmq_msg_set_reason (self, "Life is short but Now lasts for ever");
// Send twice
fmq_msg_send (self, output);
fmq_msg_send (self, output);
for (instance = 0; instance < 2; instance++) {
fmq_msg_recv (self, input);
assert (fmq_msg_routing_id (self));
assert (streq (fmq_msg_reason (self), "Life is short but Now lasts for ever"));
}
fmq_msg_destroy (&self);
zsock_destroy (&input);
zsock_destroy (&output);
// @end
printf ("OK\n");
}
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);
}
void
zproto_example_test (bool verbose)
{
printf (" * zproto_example:");
if (verbose)
printf ("\n");
// @selftest
// Simple create/destroy test
zproto_example_t *self = zproto_example_new ();
assert (self);
zproto_example_destroy (&self);
// Create pair of sockets we can send through
// We must bind before connect if we wish to remain compatible with ZeroMQ < v4
zsock_t *output = zsock_new (ZMQ_DEALER);
assert (output);
int rc = zsock_bind (output, "inproc://selftest-zproto_example");
assert (rc == 0);
zsock_t *input = zsock_new (ZMQ_ROUTER);
assert (input);
rc = zsock_connect (input, "inproc://selftest-zproto_example");
assert (rc == 0);
// Encode/send/decode and verify each message type
int instance;
self = zproto_example_new ();
zproto_example_set_id (self, ZPROTO_EXAMPLE_LOG);
zproto_example_set_sequence (self, 123);
zproto_example_set_level (self, 2);
zproto_example_set_event (self, 3);
zproto_example_set_node (self, 45536);
zproto_example_set_peer (self, 65535);
zproto_example_set_time (self, 1427261426);
zproto_example_set_host (self, "localhost");
zproto_example_set_data (self, "This is the message to log");
// Send twice
zproto_example_send (self, output);
zproto_example_send (self, output);
for (instance = 0; instance < 2; instance++) {
zproto_example_recv (self, input);
assert (zproto_example_routing_id (self));
assert (zproto_example_sequence (self) == 123);
assert (zproto_example_level (self) == 2);
assert (zproto_example_event (self) == 3);
assert (zproto_example_node (self) == 45536);
assert (zproto_example_peer (self) == 65535);
assert (zproto_example_time (self) == 1427261426);
assert (streq (zproto_example_host (self), "localhost"));
assert (streq (zproto_example_data (self), "This is the message to log"));
}
zproto_example_set_id (self, ZPROTO_EXAMPLE_STRUCTURES);
zproto_example_set_sequence (self, 123);
zlist_t *structures_aliases = zlist_new ();
zlist_append (structures_aliases, "First alias");
zlist_append (structures_aliases, "Second alias");
zlist_append (structures_aliases, "Third alias");
zproto_example_set_aliases (self, &structures_aliases);
zhash_t *structures_headers = zhash_new ();
zhash_insert (structures_headers, "endpoint", "tcp://*****:*****@example.com");
zproto_example_set_supplier_forename (self, "Leslie");
zproto_example_set_supplier_surname (self, "Lamport");
zproto_example_set_supplier_mobile (self, "01987654321");
zproto_example_set_supplier_email (self, "*****@*****.**");
// Send twice
zproto_example_send (self, output);
zproto_example_send (self, output);
for (instance = 0; instance < 2; instance++) {
zproto_example_recv (self, input);
assert (zproto_example_routing_id (self));
assert (zproto_example_sequence (self) == 123);
assert (streq (zproto_example_client_forename (self), "Lucius Junius"));
assert (streq (zproto_example_client_surname (self), "Brutus"));
assert (streq (zproto_example_client_mobile (self), "01234567890"));
assert (streq (zproto_example_client_email (self), "*****@*****.**"));
assert (streq (zproto_example_supplier_forename (self), "Leslie"));
assert (streq (zproto_example_supplier_surname (self), "Lamport"));
assert (streq (zproto_example_supplier_mobile (self), "01987654321"));
assert (streq (zproto_example_supplier_email (self), "*****@*****.**"));
}
zproto_example_destroy (&self);
zsock_destroy (&input);
zsock_destroy (&output);
// @end
printf ("OK\n");
}
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);
}
///
// After a successful first/next method, returns the key for the item that
// was returned. This is a constant string that you may not modify or
// deallocate, and which lasts as long as the item in the hash. After an
// unsuccessful first/next, returns NULL.
const QString QZhash::cursor ()
{
const QString rv = QString (zhash_cursor (self));
return rv;
}
int
fmq_msg_send (fmq_msg_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 FMQ_MSG_OHAI:
frame_size += 1 + strlen ("FILEMQ");
frame_size += 2; // version
break;
case FMQ_MSG_ICANHAZ:
frame_size += 4;
if (self->path)
frame_size += strlen (self->path);
frame_size += 4; // Size is 4 octets
if (self->options) {
self->options_bytes = 0;
char *item = (char *) zhash_first (self->options);
while (item) {
self->options_bytes += 1 + strlen (zhash_cursor (self->options));
self->options_bytes += 4 + strlen (item);
item = (char *) zhash_next (self->options);
}
}
frame_size += self->options_bytes;
frame_size += 4; // Size is 4 octets
if (self->cache) {
self->cache_bytes = 0;
char *item = (char *) zhash_first (self->cache);
while (item) {
self->cache_bytes += 1 + strlen (zhash_cursor (self->cache));
self->cache_bytes += 4 + strlen (item);
item = (char *) zhash_next (self->cache);
}
}
frame_size += self->cache_bytes;
break;
case FMQ_MSG_NOM:
frame_size += 8; // credit
frame_size += 8; // sequence
break;
case FMQ_MSG_CHEEZBURGER:
frame_size += 8; // sequence
frame_size += 1; // operation
frame_size += 4;
if (self->filename)
frame_size += strlen (self->filename);
frame_size += 8; // offset
frame_size += 1; // eof
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;
frame_size += 4; // Size is 4 octets
if (self->chunk)
frame_size += zchunk_size (self->chunk);
break;
case FMQ_MSG_SRSLY:
frame_size += 1 + strlen (self->reason);
break;
case FMQ_MSG_RTFM:
frame_size += 1 + strlen (self->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 | 3);
PUT_NUMBER1 (self->id);
size_t nbr_frames = 1; // Total number of frames to send
switch (self->id) {
case FMQ_MSG_OHAI:
PUT_STRING ("FILEMQ");
PUT_NUMBER2 (FMQ_MSG_VERSION);
break;
case FMQ_MSG_ICANHAZ:
if (self->path) {
PUT_LONGSTR (self->path);
}
else
PUT_NUMBER4 (0); // Empty string
if (self->options) {
PUT_NUMBER4 (zhash_size (self->options));
char *item = (char *) zhash_first (self->options);
while (item) {
PUT_STRING (zhash_cursor (self->options));
PUT_LONGSTR (item);
item = (char *) zhash_next (self->options);
}
}
else
PUT_NUMBER4 (0); // Empty hash
if (self->cache) {
PUT_NUMBER4 (zhash_size (self->cache));
char *item = (char *) zhash_first (self->cache);
while (item) {
PUT_STRING (zhash_cursor (self->cache));
PUT_LONGSTR (item);
item = (char *) zhash_next (self->cache);
}
}
else
PUT_NUMBER4 (0); // Empty hash
break;
case FMQ_MSG_NOM:
PUT_NUMBER8 (self->credit);
PUT_NUMBER8 (self->sequence);
break;
case FMQ_MSG_CHEEZBURGER:
PUT_NUMBER8 (self->sequence);
PUT_NUMBER1 (self->operation);
if (self->filename) {
PUT_LONGSTR (self->filename);
}
else
PUT_NUMBER4 (0); // Empty string
PUT_NUMBER8 (self->offset);
PUT_NUMBER1 (self->eof);
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
if (self->chunk) {
PUT_NUMBER4 (zchunk_size (self->chunk));
memcpy (self->needle,
zchunk_data (self->chunk),
zchunk_size (self->chunk));
self->needle += zchunk_size (self->chunk);
}
else
PUT_NUMBER4 (0); // Empty chunk
break;
case FMQ_MSG_SRSLY:
PUT_STRING (self->reason);
break;
case FMQ_MSG_RTFM:
PUT_STRING (self->reason);
break;
}
// Now send the data frame
zmq_msg_send (&frame, zsock_resolve (output), --nbr_frames? ZMQ_SNDMORE: 0);
return 0;
}
void
fmq_msg_print (fmq_msg_t *self)
{
assert (self);
switch (self->id) {
case FMQ_MSG_OHAI:
zsys_debug ("FMQ_MSG_OHAI:");
zsys_debug (" protocol=filemq");
zsys_debug (" version=fmq_msg_version");
break;
case FMQ_MSG_OHAI_OK:
zsys_debug ("FMQ_MSG_OHAI_OK:");
break;
case FMQ_MSG_ICANHAZ:
zsys_debug ("FMQ_MSG_ICANHAZ:");
if (self->path)
zsys_debug (" path='%s'", self->path);
else
zsys_debug (" path=");
zsys_debug (" options=");
if (self->options) {
char *item = (char *) zhash_first (self->options);
while (item) {
zsys_debug (" %s=%s", zhash_cursor (self->options), item);
item = (char *) zhash_next (self->options);
}
}
else
zsys_debug ("(NULL)");
zsys_debug (" cache=");
if (self->cache) {
char *item = (char *) zhash_first (self->cache);
while (item) {
zsys_debug (" %s=%s", zhash_cursor (self->cache), item);
item = (char *) zhash_next (self->cache);
}
}
else
zsys_debug ("(NULL)");
break;
case FMQ_MSG_ICANHAZ_OK:
zsys_debug ("FMQ_MSG_ICANHAZ_OK:");
break;
case FMQ_MSG_NOM:
zsys_debug ("FMQ_MSG_NOM:");
zsys_debug (" credit=%ld", (long) self->credit);
zsys_debug (" sequence=%ld", (long) self->sequence);
break;
case FMQ_MSG_CHEEZBURGER:
zsys_debug ("FMQ_MSG_CHEEZBURGER:");
zsys_debug (" sequence=%ld", (long) self->sequence);
zsys_debug (" operation=%ld", (long) self->operation);
if (self->filename)
zsys_debug (" filename='%s'", self->filename);
else
zsys_debug (" filename=");
zsys_debug (" offset=%ld", (long) self->offset);
zsys_debug (" eof=%ld", (long) self->eof);
zsys_debug (" headers=");
if (self->headers) {
char *item = (char *) zhash_first (self->headers);
while (item) {
zsys_debug (" %s=%s", zhash_cursor (self->headers), item);
item = (char *) zhash_next (self->headers);
}
}
else
zsys_debug ("(NULL)");
zsys_debug (" chunk=[ ... ]");
break;
case FMQ_MSG_HUGZ:
zsys_debug ("FMQ_MSG_HUGZ:");
break;
case FMQ_MSG_HUGZ_OK:
zsys_debug ("FMQ_MSG_HUGZ_OK:");
break;
case FMQ_MSG_KTHXBAI:
zsys_debug ("FMQ_MSG_KTHXBAI:");
break;
case FMQ_MSG_SRSLY:
zsys_debug ("FMQ_MSG_SRSLY:");
zsys_debug (" reason='%s'", self->reason);
break;
case FMQ_MSG_RTFM:
zsys_debug ("FMQ_MSG_RTFM:");
zsys_debug (" reason='%s'", self->reason);
break;
}
}
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;
}
void
zproto_example_print (zproto_example_t *self)
{
assert (self);
switch (self->id) {
case ZPROTO_EXAMPLE_LOG:
zsys_debug ("ZPROTO_EXAMPLE_LOG:");
zsys_debug (" sequence=%ld", (long) self->sequence);
zsys_debug (" version=3");
zsys_debug (" level=%ld", (long) self->level);
zsys_debug (" event=%ld", (long) self->event);
zsys_debug (" node=%ld", (long) self->node);
zsys_debug (" peer=%ld", (long) self->peer);
zsys_debug (" time=%ld", (long) self->time);
zsys_debug (" host='%s'", self->host);
if (self->data)
zsys_debug (" data='%s'", self->data);
else
zsys_debug (" data=");
break;
case ZPROTO_EXAMPLE_STRUCTURES:
zsys_debug ("ZPROTO_EXAMPLE_STRUCTURES:");
zsys_debug (" sequence=%ld", (long) self->sequence);
zsys_debug (" aliases=");
if (self->aliases) {
char *aliases = (char *) zlist_first (self->aliases);
while (aliases) {
zsys_debug (" '%s'", aliases);
aliases = (char *) zlist_next (self->aliases);
}
}
zsys_debug (" headers=");
if (self->headers) {
char *item = (char *) zhash_first (self->headers);
while (item) {
zsys_debug (" %s=%s", zhash_cursor (self->headers), item);
item = (char *) zhash_next (self->headers);
}
}
else
zsys_debug ("(NULL)");
break;
case ZPROTO_EXAMPLE_BINARY:
zsys_debug ("ZPROTO_EXAMPLE_BINARY:");
zsys_debug (" sequence=%ld", (long) self->sequence);
zsys_debug (" flags=[ ... ]");
zsys_debug (" public_key=[ ... ]");
zsys_debug (" identifier=");
if (self->identifier)
zsys_debug (" %s", zuuid_str_canonical (self->identifier));
else
zsys_debug (" (NULL)");
zsys_debug (" address=");
if (self->address)
zframe_print (self->address, NULL);
else
zsys_debug ("(NULL)");
zsys_debug (" content=");
if (self->content)
zmsg_print (self->content);
else
zsys_debug ("(NULL)");
break;
case ZPROTO_EXAMPLE_TYPES:
zsys_debug ("ZPROTO_EXAMPLE_TYPES:");
zsys_debug (" sequence=%ld", (long) self->sequence);
zsys_debug (" client_forename='%s'", self->client_forename);
zsys_debug (" client_surname='%s'", self->client_surname);
zsys_debug (" client_mobile='%s'", self->client_mobile);
zsys_debug (" client_email='%s'", self->client_email);
zsys_debug (" supplier_forename='%s'", self->supplier_forename);
zsys_debug (" supplier_surname='%s'", self->supplier_surname);
zsys_debug (" supplier_mobile='%s'", self->supplier_mobile);
zsys_debug (" supplier_email='%s'", self->supplier_email);
break;
}
}
