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
zhash_foreach (self->peers, (zhash_foreach_fn *) zyre_node_purge_peer, (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);
// Handshake discovery by sending HELLO as first message
zlist_t *groups = zhash_keys (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 zre_peer_t *
s_require_peer (agent_t *self, char *identity, char *address, uint16_t port)
{
zre_peer_t *peer = (zre_peer_t *) zhash_lookup (self->peers, identity);
if (!peer) {
// Purge any previous peer on same endpoint
char endpoint [100];
snprintf (endpoint, 100, "%s:%hu", address, port);
zhash_foreach (self->peers, agent_peer_purge, endpoint);
peer = zre_peer_new (identity, self->peers, self->ctx);
zre_peer_connect (peer, self->identity, endpoint);
// Handshake discovery by sending HELLO as first message
zre_msg_t *msg = zre_msg_new (ZRE_MSG_HELLO);
zre_msg_ipaddress_set (msg, zre_udp_host (self->udp));
zre_msg_mailbox_set (msg, self->port);
zre_msg_groups_set (msg, zhash_keys (self->own_groups));
zre_msg_status_set (msg, self->status);
zre_msg_headers_set (msg, zhash_dup (self->headers));
zre_peer_send (peer, &msg);
zre_log_info (self->log, ZRE_LOG_MSG_EVENT_ENTER,
zre_peer_endpoint (peer), endpoint);
// Now tell the caller about the peer
zstr_sendm (self->pipe, "ENTER");
zstr_send (self->pipe, identity);
}
return peer;
}
int module_event_mcast (modhash_t *mh, const flux_msg_t *msg)
{
const char *topic;
zlist_t *uuids;
char *uuid;
int rc = -1;
if (flux_msg_get_topic (msg, &topic) < 0)
goto done;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (match_sub (p, topic)) {
if (module_sendmsg (p, msg) < 0)
goto done;
}
uuid = zlist_next (uuids);
}
rc = 0;
done:
zlist_destroy (&uuids);
return rc;
}
void
ztask_job_request_clean (ztask_job_request_t *self, ztask_node_manager_t *node_mgr)
{
assert (self);
// zclock_log ("Cleaning job request from %s ...", zyre_event_sender (self->request));
zlist_t *keys = zhash_keys (self->processes);
char *key = (char *) zlist_first (keys);
ztask_job_proc_t *p;
int pid;
while (key) {
p = (ztask_job_proc_t *) zhash_lookup (self->processes, key);
zhash_delete (self->processes, key);
pid = ztask_job_proc_pid(p);
// assert (pid);
if (pid) {
zclock_log("Killing pid=%d ...", ztask_job_proc_pid(p));
kill (ztask_job_proc_pid(p), SIGKILL);
zmsg_t *msg_report = zmsg_new ();
zmsg_addstr (msg_report, "REPORT");
zmsg_addstr (msg_report, ztask_job_proc_jobid(p));
zmsg_addstr (msg_report, "-100");
zyre_whisper (ztask_node_manager_zyre_node(node_mgr), zyre_event_sender(self->request), &msg_report);
zmsg_destroy (&msg_report);
zhash_delete (ztask_node_manager_list_running_processes (node_mgr), ztask_job_proc_jobid(p));
zlist_append (ztask_node_manager_list_available_processes (node_mgr), p);
ztask_job_proc_reset(p);
}
key = (char *) zlist_next (keys);
}
zlist_destroy (&keys);
}
static
void setup_subscriptions(subscriber_state_t *state)
{
zlist_t *subscriptions = zhash_keys(stream_subscriptions);
setup_subscriptions_for_sub_socket(subscriptions, state->sub_socket);
zlist_destroy(&subscriptions);
}
static void _devio_destroy_smio_all (devio_t *self)
{
#if 0
unsigned i;
for (i = 0; i < self->nnodes; ++i) {
/* This cannot fail at this point... but it can */
zmsg_t *msg = zmsg_new ();
/* An empty message means to selfdestruct */
zmsg_pushstr (msg, "");
zmsg_send (&msg, self->pipes [i]);
}
#endif
/* Get all hash keys */
zlist_t *hash_keys = zhash_keys (self->sm_io_h);
ASSERT_ALLOC (hash_keys, err_hash_keys_alloc);
char *hash_item = zlist_first (hash_keys);
/* Iterate over all keys removing each of one */
for (; hash_item != NULL; hash_item = zlist_next (hash_keys)) {
/* FIXME: Usage of stroul fucntion for reconverting the string
* into a uint32_t */
_devio_destroy_smio (self, (uint32_t) strtoul (hash_item,
(char **) NULL, 16));
}
zlist_destroy (&hash_keys);
err_hash_keys_alloc:
return;
}
flux_modlist_t module_get_modlist (modhash_t *mh)
{
flux_modlist_t mods;
zlist_t *uuids;
char *uuid;
module_t *p;
if (!(mods = flux_modlist_create ()))
goto done;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (flux_modlist_append (mods, module_get_name (p), p->size,
p->digest, module_get_idle (p)) < 0) {
flux_modlist_destroy (mods);
mods = NULL;
goto done;
}
uuid = zlist_next (uuids);
}
done:
zlist_destroy (&uuids);
return mods;
}
void cache_get_stats (struct cache *cache, tstat_t *ts, int *sizep,
int *incompletep, int *dirtyp)
{
zlist_t *keys;
struct cache_entry *hp;
char *ref;
int size = 0;
int incomplete = 0;
int dirty = 0;
if (!(keys = zhash_keys (cache->zh)))
oom ();
while ((ref = zlist_pop (keys))) {
hp = zhash_lookup (cache->zh, ref);
if (cache_entry_get_valid (hp)) {
int obj_size = strlen (Jtostr (hp->o));
size += obj_size;
tstat_push (ts, obj_size);
} else
incomplete++;
if (cache_entry_get_dirty (hp))
dirty++;
free (ref);
}
zlist_destroy (&keys);
if (sizep)
*sizep = size;
if (incompletep)
*incompletep = incomplete;
if (dirtyp)
*dirtyp = dirty;
}
static int cb_rlist_result (zhash_t *mods, flux_lsmod_f cb, void *arg)
{
zlist_t *keys = zhash_keys (mods);
char *key;
int rc = -1;
if (!keys) {
errno = ENOMEM;
goto done;
}
key = zlist_first (keys);
while (key) {
module_t *m = zhash_lookup (mods, key);
if (m) {
const char *ns = nodeset_str (m->nodeset);
if (cb (m->name, m->size, m->digest, m->idle, ns, arg) < 0)
goto done;
}
key = zlist_next (keys);
}
rc = 0;
done:
zlist_destroy (&keys);
return rc;
}
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;
}
/* N.B. services is hardwired to test1,test2,testN, where N is the local
* broker rank. This is a specific setup for the flux-module test. This
* base component does not perform message routing to its extension modules.
*/
static json_t *module_list (void)
{
json_t *mods;
zlist_t *keys;
module_t *m;
char *name;
char rankstr[16];
int n;
if (!(mods = json_array ()))
oom ();
if (!(keys = zhash_keys (modules)))
oom ();
name = zlist_first (keys);
n = snprintf (rankstr, sizeof (rankstr), "rank%d", (int)rank);
assert (n < sizeof (rankstr));
while (name) {
json_t *o;
m = zhash_lookup (modules, name);
if (!(o = json_pack ("{s:s s:i s:s s:i s:i s:[s,s,s]}",
"name", m->name,
"size", m->size,
"digest", m->digest,
"idle", m->idle,
"status", m->status,
"services", "test1", "test2", rankstr)))
oom ();
if (json_array_append_new (mods, o) < 0)
oom ();
name = zlist_next (keys);
}
zlist_destroy (&keys);
return mods;
}
static zsync_node_t *
zsync_node_new ()
{
int rc;
zsync_node_t *self = (zsync_node_t *) zmalloc (sizeof (zsync_node_t));
self->ctx = zctx_new ();
assert (self->ctx);
self->zyre = zyre_new (self->ctx);
assert (self->zyre);
// Obtain permanent UUID
self->own_uuid = zuuid_new ();
if (zsys_file_exists (UUID_FILE)) {
// Read uuid from file
zfile_t *uuid_file = zfile_new (".", UUID_FILE);
int rc = zfile_input (uuid_file); // open file for reading
assert (rc == 0);
zchunk_t *uuid_chunk = zfile_read (uuid_file, 16, 0);
assert (zchunk_size (uuid_chunk) == 16); // make sure read succeeded
zuuid_set (self->own_uuid, zchunk_data (uuid_chunk));
zfile_destroy (&uuid_file);
} else {
// Write uuid to file
zfile_t *uuid_file = zfile_new (".", UUID_FILE);
rc = zfile_output (uuid_file); // open file for writing
assert (rc == 0);
zchunk_t *uuid_bin = zchunk_new ( zuuid_data (self->own_uuid), 16);
rc = zfile_write (uuid_file, uuid_bin, 0);
assert (rc == 0);
zfile_destroy (&uuid_file);
}
// Obtain peers and states
self->peers = zlist_new ();
if (zsys_file_exists (PEER_STATES_FILE)) {
zhash_t *peer_states = zhash_new ();
int rc = zhash_load (peer_states, PEER_STATES_FILE);
assert (rc == 0);
zlist_t *uuids = zhash_keys (peer_states);
char *uuid = zlist_first (uuids);
while (uuid) {
char * state_str = zhash_lookup (peer_states, uuid);
uint64_t state;
sscanf (state_str, "%"SCNd64, &state);
zlist_append (self->peers, zsync_peer_new (uuid, state));
uuid = zlist_next (uuids);
}
}
self->zyre_peers = zhash_new ();
self->terminated = false;
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);
}
halutils_err_e disp_table_remove_all (disp_table_t *self)
{
assert (self);
zlist_t *hash_keys = zhash_keys (self->table_h);
void * table_item = zlist_first (hash_keys);
for (; table_item; table_item = zlist_next (hash_keys)) {
zhash_delete (self->table_h, (char *) table_item);
}
zlist_destroy (&hash_keys);
return HALUTILS_SUCCESS;
}
static char *
zsync_node_zyre_uuid (zsync_node_t *self, char *sender)
{
assert (self);
assert (sender);
zlist_t *keys = zhash_keys (self->zyre_peers);
char *key = zlist_first (keys);
while (key) {
zsync_peer_t *peer = zhash_lookup (self->zyre_peers, key);
if (peer && streq (sender, zsync_peer_uuid (peer))) {
return key;
}
key = zlist_next (keys);
}
return NULL;
}
static void freectx (void *arg)
{
ctx_t *ctx = arg;
zlist_t *keys = zhash_keys (ctx->ping_requests);
char *key = zlist_first (keys);
while (key) {
zmsg_t *zmsg = zhash_lookup (ctx->ping_requests, key);
zmsg_destroy (&zmsg);
key = zlist_next (keys);
}
zlist_destroy (&keys);
zhash_destroy (&ctx->ping_requests);
zmsg_t *zmsg;
while ((zmsg = zlist_pop (ctx->clog_requests)))
zmsg_destroy (&zmsg);
zlist_destroy (&ctx->clog_requests);
free (ctx);
}
void
ztask_job_request_dump (ztask_job_request_t *self)
{
assert (self);
zclock_log("ztask_job_request: Processes=%ld", zhash_size (self->processes));
zlist_t *keys = zhash_keys (self->processes);
char *key = (char *) zlist_first (keys);
ztask_job_proc_t *p;
while (key) {
zclock_log ("ztask_job_request: key=%s", key);
p = (ztask_job_proc_t *) zhash_lookup (self->processes, key);
ztask_job_proc_dump (p);
key = (char *) zlist_next (keys);
}
zlist_destroy (&keys);
}
int module_start_all (modhash_t *mh)
{
zlist_t *uuids;
char *uuid;
int rc = -1;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (module_start (p) < 0)
goto done;
uuid = zlist_next (uuids);
}
rc = 0;
done:
zlist_destroy (&uuids);
return rc;
}
int cache_expire_entries (struct cache *cache, int current_epoch, int thresh)
{
zlist_t *keys;
char *ref;
struct cache_entry *hp;
int count = 0;
if (!(keys = zhash_keys (cache->zh)))
oom ();
while ((ref = zlist_pop (keys))) {
if ((hp = zhash_lookup (cache->zh, ref))
&& !cache_entry_get_dirty (hp)
&& cache_entry_get_valid (hp)
&& (thresh == 0 || cache_entry_age (hp, current_epoch) > thresh)) {
zhash_delete (cache->zh, ref);
count++;
}
free (ref);
}
zlist_destroy (&keys);
return count;
}
module_t *module_lookup_byname (modhash_t *mh, const char *name)
{
zlist_t *uuids;
char *uuid;
module_t *result = NULL;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (!strcmp (module_get_name (p), name)) {
result = p;
break;
}
uuid = zlist_next (uuids);
p = NULL;
}
zlist_destroy (&uuids);
return result;
}
void lsmod_map_hash (zhash_t *mods, flux_lsmod_f cb, void *arg)
{
zlist_t *keys = NULL;
const char *key;
mod_t *m;
int errnum = 0;
if (!(keys = zhash_keys (mods)))
oom ();
key = zlist_first (keys);
while (key != NULL) {
if ((m = zhash_lookup (mods, key))) {
if (cb (m->name, m->size, m->digest, m->idle,
nodeset_str (m->nodeset), arg) < 0) {
if (errno > errnum)
errnum = errno;
}
}
key = zlist_next (keys);
}
zlist_destroy (&keys);
}
static void emit_command_help_from_pattern (const char *pattern, FILE *fp)
{
zhash_t *zh = NULL;
zlist_t *keys = NULL;
const char *cat;
zh = get_command_list_hash (pattern);
if (zh == NULL)
return;
keys = zhash_keys (zh);
zlist_sort (keys, (zlist_compare_fn *) category_cmp);
cat = zlist_first (keys);
while (cat) {
emit_command_list_category (zh, cat, fp);
if ((cat = zlist_next (keys)))
fprintf (fp, "\n");
}
zlist_destroy (&keys);
zhash_destroy (&zh);
return;
}
void
zhash_test (int verbose)
{
printf (" * zhash: ");
// @selftest
zhash_t *hash = zhash_new ();
assert (hash);
assert (zhash_size (hash) == 0);
// Insert some items
int rc;
rc = zhash_insert (hash, "DEADBEEF", "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
char *item;
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 foreach
rc = zhash_foreach (hash, test_foreach, hash);
assert (rc == 0);
rc = zhash_foreach (hash, test_foreach_error, hash);
assert (rc == -1);
// 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 ();
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 ();
zhash_autofree (hash);
char value [255];
strcpy (value, "This is a string");
rc = zhash_insert (hash, "key1", value);
assert (rc == 0);
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");
}
zlist_t *
zcert_meta_keys (zcert_t *self)
{
assert (self);
return zhash_keys (self->metadata);
}
void
ztask_run_manager_loop (ztask_run_manager_t *self)
{
assert (self);
if (!self->packetizer) {
zclock_log ("E: No packetizer set !!!");
return;
}
// Setting network interface if neede
if (self->node_interface)
zyre_set_interface(self->node, self->node_interface);
zyre_set_header (self->node, "X-ZTASK-RUN", "ZTASK RUN");
zyre_start (self->node);
zyre_dump (self->node);
zclock_sleep (10);
// ztask_packetizer_dump (self->packetizer);
ztask_packet_t *packet;
int request_sent = 0;
zyre_event_t *event;
while (!zsys_interrupted) {
if (ztask_packetizer_is_finished (self->packetizer))
break;
event = zyre_event_new (self->node);
if (!event)
break;
if (zyre_event_type (event) == ZYRE_EVENT_ENTER) {
// Ignoring nodes which don't have service X-ZTASK-NODE defined
if (zyre_event_header (event, "X-ZTASK-NODE")) {
zhash_insert (self->nodes, zyre_event_sender (event),"");
ztask_log_debug (self->log, "Adding node -> workers=%ld", zhash_size (self->nodes));
} else {
// TODO disconnect worker (zyre peer) somehow
}
}
else
if (zyre_event_type (event) == ZYRE_EVENT_EXIT) {
if (zhash_lookup (self->nodes, zyre_event_sender (event))) {
ztask_log_debug (self->log, "Removing node -> workers=%ld", zhash_size (self->nodes));
zhash_delete (self->nodes, zyre_event_sender (event));
// Cleanup packetizer in case ztask_node was killed
request_sent -= ztask_packetizer_running_node_cleanup (self->packetizer, zyre_event_sender (event));
}
}
else
if (zyre_event_type (event) == ZYRE_EVENT_WHISPER) {
// Ingoring whispers when they are not from our nodes
if (!zhash_lookup(self->nodes, zyre_event_sender (event))) {
ztask_log_warning (self->log, "W: Ingoring whisper from %s", zyre_event_sender (event));
zyre_event_destroy (&event);
continue;
}
zmsg_t *msg_report = zyre_event_msg(event);
char *str_msg = zmsg_popstr (msg_report);
if (streq(str_msg, "REQUEST")) {
// Let's handle request
packet = ztask_packetizer_next_packet (self->packetizer);
if (packet) {
char *cmd;
if ( asprintf (&cmd, "%s", ztask_packet_cmd (packet)) < 0)
cmd = NULL;
assert (cmd);
zmsg_t *msg = zmsg_new ();
zmsg_addstr (msg, "REQUEST");
zmsg_addstrf (msg, "%s_%ld", zyre_uuid (self->node), ztask_packet_id (packet));
zmsg_addstr (msg, cmd);
zyre_whisper (self->node, zyre_event_sender (event), &msg);
ztask_packet_set_node (packet, zyre_event_sender (event));
request_sent++;
ztask_packetizer_info (self->packetizer, request_sent);
ztask_log_debug (self->log, "ID=%s_%ld cmd='%s' running=%d", zyre_uuid (self->node), ztask_packet_id (packet), cmd, request_sent);
free (cmd);
}
else {
zmsg_t *msg = zmsg_new ();
zmsg_addstr (msg, "NO_PACKETS");
zyre_whisper (self->node, zyre_event_sender (event), &msg);
}
}
else
if (streq(str_msg, "REPORT")) {
// It's report
char *str_id = zmsg_popstr (msg_report);
char *str_pid_rc = zmsg_popstr (msg_report);
ztask_log_debug (self->log, "REPORT ID=%s rc=%s", str_id, str_pid_rc);
ztask_packetizer_report (self->packetizer, str_id, str_pid_rc);
request_sent--;
ztask_packetizer_info (self->packetizer, request_sent);
free (str_id);
free (str_pid_rc);
}
else {
ztask_log_error (self->log, "E: ztask_run_manager_loop : Wrong message %s", str_msg);
assert (false);
}
free (str_msg);
}
zyre_event_destroy (&event);
}
// FIXME : simplify zhash_foreach()
zlist_t *keys = zhash_keys (self->nodes);
char *key = (char *) zlist_first (keys);
while (key) {
zmsg_t *msg = zmsg_new ();
zmsg_addstr (msg, "END");
zyre_whisper (self->node, key, &msg);
key = (char *) zlist_next (keys);
}
zlist_destroy (&keys);
// wait for shout to be delivered
zclock_sleep (100);
ztask_packetizer_summary(self->packetizer, 0);
zyre_stop (self->node);
}
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);
}
///
// Return keys for items in table
QZlist * QZhash::keys ()
{
QZlist *rv = new QZlist (zhash_keys (self));
return rv;
}
void
zhash_test (int verbose)
{
printf (" * zhash: ");
// @selftest
zhash_t *hash = zhash_new ();
assert (hash);
assert (zhash_size (hash) == 0);
// Insert some items
int rc;
rc = zhash_insert (hash, "DEADBEEF", "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
char *item;
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"));
// Rename an item
rc = zhash_rename (hash, "DEADBEEF", "LIVEBEEF");
assert (rc == 0);
rc = zhash_rename (hash, "WHATBEEF", "LIVEBEEF");
assert (rc == -1);
// 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 foreach
assert (0 == zhash_foreach (hash, test_foreach, hash));
assert (-1 == zhash_foreach (hash, test_foreach_error, hash));
// Test save and load
zhash_save (hash, ".cache");
copy = zhash_new ();
zhash_load (copy, ".cache");
item = (char *) zhash_lookup (copy, "LIVEBEEF");
assert (item);
assert (streq (item, "dead beef"));
zhash_destroy (©);
#if (defined (WIN32))
DeleteFile (".cache");
#else
unlink (".cache");
#endif
// 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);
// @end
printf ("OK\n");
}
