static void
server_connect (server_t *self, const char *endpoint)
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_unbounded (remote);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_warning ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_t *gossip = zgossip_msg_new ();
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (gossip, remote);
tuple_t *tuple = (tuple_t *) zhashx_first (self->tuples);
while (tuple) {
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_PUBLISH);
zgossip_msg_set_key (gossip, tuple->key);
zgossip_msg_set_value (gossip, tuple->value);
zgossip_msg_send (gossip, remote);
tuple = (tuple_t *) zhashx_next (self->tuples);
}
// Now monitor this remote for incoming messages
zgossip_msg_destroy (&gossip);
engine_handle_socket (self, remote, remote_handler);
zlistx_add_end (self->remotes, remote);
}
static void
server_leave_cluster (server_t *self)
{
// Cancel reader for Zyre events
engine_handle_socket (self, zyre_socket (self->zyre), NULL);
zyre_destroy (&self->zyre);
}
static void
server_connect (server_t *self, const char *endpoint)
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_sndhwm (remote, 0);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_error ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_send_hello (remote);
tuple_t *tuple = (tuple_t *) zhash_first (self->tuples);
while (tuple) {
int rc = zgossip_msg_send_publish (remote, tuple->key, tuple->value, 0);
assert (rc == 0);
tuple = (tuple_t *) zhash_next (self->tuples);
}
// Now monitor this remote for incoming messages
engine_handle_socket (self, remote, remote_handler);
zlist_append (self->remotes, remote);
}
server_connect (server_t *self, const char *endpoint)
#endif
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
#ifdef CZMQ_BUILD_DRAFT_API
// DRAFT-API: Security
if (public_key){
zcert_t *cert = zcert_new_from_txt (self->public_key, self->secret_key);
zcert_apply(cert, remote);
zsock_set_curve_serverkey (remote, public_key);
#ifndef ZMQ_CURVE
// legacy ZMQ support
// inline incase the underlying assert is removed
bool ZMQ_CURVE = false;
#endif
assert (zsock_mechanism (remote) == ZMQ_CURVE);
zcert_destroy(&cert);
}
#endif
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_unbounded (remote);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_warning ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_t *gossip = zgossip_msg_new ();
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (gossip, remote);
tuple_t *tuple = (tuple_t *) zhashx_first (self->tuples);
while (tuple) {
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_PUBLISH);
zgossip_msg_set_key (gossip, tuple->key);
zgossip_msg_set_value (gossip, tuple->value);
zgossip_msg_send (gossip, remote);
tuple = (tuple_t *) zhashx_next (self->tuples);
}
// Now monitor this remote for incoming messages
zgossip_msg_destroy (&gossip);
engine_handle_socket (self, remote, remote_handler);
zlistx_add_end (self->remotes, remote);
}
static stream_t *
s_stream_new (client_t *client, const char *name)
{
stream_t *self = (stream_t *) zmalloc (sizeof (stream_t));
if (self) {
zsock_t *backend;
self->name = strdup (name);
if (self->name)
self->msgpipe = zsys_create_pipe (&backend);
if (self->msgpipe) {
engine_handle_socket (client->server, self->msgpipe, s_forward_stream_traffic);
self->actor = zactor_new (mlm_stream_simple, backend);
}
if (!self->actor)
s_stream_destroy (&self);
}
return self;
}
static int
server_join_cluster (server_t *self)
{
self->zyre = zyre_new (zconfig_resolve (self->config, "zyre/name", NULL));
// Get Zyre configuration properties
char *value = zconfig_resolve (self->config, "zyre/discovery", "beacon");
if (streq (value, "beacon")) {
// Set-up UDP beacon discovery
zsys_info ("using UDP beacon discovery service");
value = zconfig_resolve (self->config, "zyre/beacon/interface", "auto");
if (strneq (value, "auto")) {
zsys_info ("forcing cluster interface to %s", value);
zyre_set_interface (self->zyre, value);
}
value = zconfig_resolve (self->config, "zyre/beacon/interval", NULL);
if (value)
zyre_set_interval (self->zyre, atoi (value));
value = zconfig_resolve (self->config, "zyre/beacon/port", NULL);
if (value) {
zsys_info ("UDP beaconing on port %s", value);
zyre_set_port (self->zyre, atoi (value));
}
}
else
if (streq (value, "gossip")) {
// Set-up TCP gossip discovery
zsys_info ("using TCP gossip discovery service");
zconfig_t *section = zconfig_locate (self->config, "zyre/gossip");
if (!section) {
zsys_warning ("please configure zyre/gossip section");
return -1;
}
zconfig_t *entry = zconfig_child (section);
while (entry) {
char *name = zconfig_name (entry);
char *value = zconfig_value (entry);
if (streq (name, "endpoint")) {
zsys_info ("Zyre node endpoint=%s", value);
zyre_set_endpoint (self->zyre, "%s", value);
}
else
if (streq (name, "bind")) {
zsys_info ("gossip service bind to %s", value);
zyre_gossip_bind (self->zyre, "%s", value);
}
else
if (streq (name, "connect")) {
zsys_info ("gossip service connect to %s", value);
zyre_gossip_connect (self->zyre, "%s", value);
}
else
zsys_warning ("unknown zyre/gossip entry '%s' ignored", name);
entry = zconfig_next (entry);
}
}
else {
zsys_error ("bad zyre/discovery=%s (use beacon|gossip)", value);
assert (0);
}
if (zyre_start (self->zyre)) {
zsys_warning ("clustering not working");
return -1; // Can't join cluster
}
zyre_join (self->zyre, "ZPIPES");
// Get Zyre public name for logging
self->name = strdup (zyre_name (self->zyre));
zsys_info ("joining cluster as %s", self->name);
// Set-up reader for Zyre events
engine_handle_socket (self, zyre_socket (self->zyre), zyre_handler);
return 0;
}
