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; }
void zyre_peer_set_headers (zyre_peer_t *self, zhash_t *headers) { assert (self); zhash_destroy (&self->headers); self->headers = zhash_dup (headers); }
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; }
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; }
zcert_t * zcert_dup (zcert_t *source) { zcert_t *self = zcert_new_from (source->public_key, source->secret_key); zhash_destroy (&self->metadata); self->metadata = zhash_dup (source->metadata); return self; }
static sub_t * sub_new (client_t *client, char *path, zhash_t *cache) { sub_t *self = (sub_t *) zmalloc (sizeof (sub_t)); self->client = client; self->path = strdup (path); self->cache = zhash_dup (cache); zhash_foreach (self->cache, s_resolve_cache_path, self); return self; }
zre_msg_t * zre_msg_dup (zre_msg_t *self) { if (!self) return NULL; zre_msg_t *copy = zre_msg_new (self->id); if (self->routing_id) copy->routing_id = zframe_dup (self->routing_id); switch (self->id) { case ZRE_MSG_HELLO: copy->sequence = self->sequence; copy->ipaddress = self->ipaddress? strdup (self->ipaddress): NULL; copy->mailbox = self->mailbox; copy->groups = self->groups? zlist_dup (self->groups): NULL; copy->status = self->status; copy->headers = self->headers? zhash_dup (self->headers): NULL; break; case ZRE_MSG_WHISPER: copy->sequence = self->sequence; copy->content = self->content? zmsg_dup (self->content): NULL; break; case ZRE_MSG_SHOUT: copy->sequence = self->sequence; copy->group = self->group? strdup (self->group): NULL; copy->content = self->content? zmsg_dup (self->content): NULL; break; case ZRE_MSG_JOIN: copy->sequence = self->sequence; copy->group = self->group? strdup (self->group): NULL; copy->status = self->status; break; case ZRE_MSG_LEAVE: copy->sequence = self->sequence; copy->group = self->group? strdup (self->group): NULL; copy->status = self->status; break; case ZRE_MSG_PING: copy->sequence = self->sequence; break; case ZRE_MSG_PING_OK: copy->sequence = self->sequence; break; } return copy; }
zcert_t * zcert_dup (zcert_t *self) { if (self) { zcert_t *copy = zcert_new_from (self->public_key, self->secret_key); if (copy) { zhash_destroy (©->metadata); copy->metadata = zhash_dup (self->metadata); if (!copy->metadata) zcert_destroy (©); } return copy; } else return NULL; }
int zre_msg_send_hello ( void *output, uint16_t sequence, char *ipaddress, uint16_t mailbox, zlist_t *groups, byte status, zhash_t *headers) { zre_msg_t *self = zre_msg_new (ZRE_MSG_HELLO); zre_msg_set_sequence (self, sequence); zre_msg_set_ipaddress (self, ipaddress); zre_msg_set_mailbox (self, mailbox); zre_msg_set_groups (self, zlist_dup (groups)); zre_msg_set_status (self, status); zre_msg_set_headers (self, zhash_dup (headers)); return zre_msg_send (&self, output); }
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"); }
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"); }
/// // Make copy of hash table; if supplied table is null, returns null. // Does not copy items themselves. Rebuilds new table so may be slow on // very large tables. NOTE: only works with item values that are strings // since there's no other way to know how to duplicate the item value. QZhash * QZhash::dup () { QZhash *rv = new QZhash (zhash_dup (self)); return rv; }