// Worker using REQ socket to do load-balancing // static void * worker_task(void *args) { zctx_t *ctx = zctx_new(); void *worker = zsocket_new(ctx, ZMQ_REQ); #if (defined (WIN32)) zsocket_connect(worker, "tcp://localhost:5673"); // backend #else zsocket_connect(worker, "ipc://backend.ipc"); #endif // Tell broker we're ready for work zframe_t *frame = zframe_new(WORKER_READY, strlen(WORKER_READY)); zframe_send(&frame, worker, 0); // Process messages as they arrive while (1) { zmsg_t *msg = zmsg_recv(worker); if (!msg) break; // Interrupted zframe_print(zmsg_last(msg), "Worker: "); zframe_reset(zmsg_last(msg), "OK", 2); zmsg_send(&msg, worker); } zctx_destroy(&ctx); return NULL; }
int main (int argc, char *argv[]) { if (argc != 3) { exit (-1); } int numb_msgs = atoi (argv[2]); zctx_t *ctx = zctx_new (); void *dealer = zsocket_new (ctx, ZMQ_DEALER); zsocket_set_linger (dealer, -1); zsocket_connect (dealer, "%s:9000", argv[1]); void *sub = zsocket_new (ctx, ZMQ_SUB); zsocket_connect (sub, "%s:9002", argv[1]); zmq_setsockopt (sub, ZMQ_SUBSCRIBE, "all", 4); int64_t time[2]; zmq_pollitem_t pollitem[1] = { {sub, 0, ZMQ_POLLIN} }; zmq_poll (pollitem, 1, -1); zmsg_t *signal = zmsg_recv (sub); zmsg_destroy (&signal); char blob[SIZE] = { 0 }; zmsg_t *msg = zmsg_new (); zframe_t *frame = zframe_new (blob, SIZE); zmsg_add (msg, frame); time[0] = zclock_time (); int i; for (i = 0; i < numb_msgs; i++) { zmsg_t *nmsg = zmsg_dup (msg); zmsg_send (&nmsg, dealer); } time[1] = zclock_time (); zmsg_destroy (&msg); zmq_poll (pollitem, 1, -1); msg = zmsg_recv (sub); zmsg_destroy (&msg); msg = zmsg_new (); frame = zframe_new (time, sizeof (int64_t) * 2); zmsg_add (msg, frame); zmsg_send (&msg, dealer); zctx_destroy (&ctx); }
// Basic request-reply client using REQ socket // static void * client_task(void *args) { zctx_t *ctx = zctx_new(); void *client = zsocket_new(ctx, ZMQ_REQ); #if (defined (WIN32)) zsocket_connect(client, "tcp://localhost:5672"); // frontend #else zsocket_connect(client, "ipc://frontend.ipc"); #endif // Send request, get reply while (1) { zstr_send(client, "HELLO"); char *reply = zstr_recv(client); if (!reply) { break; } printf("Client: %s\n", reply); free(reply); zclock_sleep(1); } zctx_destroy(&ctx); return NULL; }
void zproxy_test (bool verbose) { printf (" * zproxy: "); // @selftest zctx_t *ctx = zctx_new (); void *frontend = zsocket_new (ctx, ZMQ_PULL); int rc = zsocket_bind (frontend, "inproc://frontend"); assert (rc == 0); void *backend = zsocket_new (ctx, ZMQ_PUSH); rc = zsocket_bind (backend, "inproc://backend"); assert (rc == 0); zproxy_t *proxy = zproxy_new (ctx, frontend, backend); // Connect application sockets to proxy void *faucet = zsocket_new (ctx, ZMQ_PUSH); rc = zsocket_connect (faucet, "inproc://frontend"); assert (rc == 0); void *sink = zsocket_new (ctx, ZMQ_PULL); rc = zsocket_connect (sink, "inproc://backend"); assert (rc == 0); // Send some messages and check they arrived zstr_send (faucet, "Hello"); char *string = zstr_recv (sink); assert (streq (string, "Hello")); zstr_free (&string); // Check pause/resume functionality zproxy_pause (proxy); zstr_send (faucet, "World"); zproxy_resume (proxy); string = zstr_recv (sink); assert (streq (string, "World")); zstr_free (&string); // Create capture socket, must be a PULL socket void *capture = zsocket_new (ctx, ZMQ_PULL); rc = zsocket_bind (capture, "inproc://capture"); assert (rc == 0); // Switch on capturing, check that it works zproxy_capture (proxy, "inproc://capture"); zstr_send (faucet, "Hello"); string = zstr_recv (sink); assert (streq (string, "Hello")); zstr_free (&string); string = zstr_recv (capture); assert (streq (string, "Hello")); zstr_free (&string); zproxy_destroy (&proxy); zctx_destroy (&ctx); // @end printf ("OK\n"); }
static void collabclient_remakeSockets( cloneclient_t *cc ) { cc->snapshot = zsocket_new (cc->ctx, ZMQ_DEALER); zsocket_connect (cc->snapshot, collabclient_makeAddressString( cc->address, cc->port + socket_offset_snapshot)); cc->subscriber = zsocket_new (cc->ctx, ZMQ_SUB); zsocket_set_subscribe (cc->subscriber, ""); zsocket_connect (cc->subscriber, collabclient_makeAddressString( cc->address, cc->port + socket_offset_subscriber)); zsocket_set_subscribe (cc->subscriber, SUBTREE); cc->publisher = zsocket_new (cc->ctx, ZMQ_PUSH); zsocket_connect (cc->publisher, collabclient_makeAddressString( cc->address, cc->port + socket_offset_publisher)); int fd = 0; size_t fdsz = sizeof(fd); int rc = zmq_getsockopt( cc->subscriber, ZMQ_FD, &fd, &fdsz ); printf("subscriber rc:%d fd:%d\n", rc, fd ); GDrawAddReadFD( 0, fd, cc, zeromq_subscriber_fd_callback ); }
int game_thread( void * _parms ) { GameThreadParms * parms = (GameThreadParms*)_parms; GameState gs; SharedRenderState rs; game_init( gs, rs ); gs.zmq_control_socket = zsocket_new( parms->zmq_context, ZMQ_PAIR ); { int ret = zsocket_connect( gs.zmq_control_socket, "inproc://control_game" ); assert( ret == 0 ); } gs.zmq_render_socket = zsocket_new( parms->zmq_context, ZMQ_PAIR ); zsocket_bind( gs.zmq_render_socket, "inproc://game_render" ); gs.zmq_input_req = zsocket_new( parms->zmq_context, ZMQ_REQ ); { int ret = zsocket_connect( gs.zmq_input_req, "inproc://input" ); assert( ret == 0 ); } unsigned int baseline = SDL_GetTicks(); int framenum = 0; while ( true ) { unsigned int now = SDL_GetTicks(); unsigned int target_frame = ( now - baseline ) / GAME_DELAY; if ( framenum <= target_frame ) { framenum++; // NOTE: build the state of the world at t = framenum * GAME_DELAY, // under normal conditions that's a time in the future // (the exception to that is if we are catching up on ticking game frames) game_tick( now, gs, rs ); // notify the render thread that a new game state is ready. // on the next render frame, it will start interpolating between the previous state and this new one zstr_sendf( gs.zmq_render_socket, "%d %f %f %f %f %f %f %f %f %f", baseline + framenum * GAME_DELAY, rs.position.x, rs.position.y, rs.orientation.w, rs.orientation.x, rs.orientation.y, rs.orientation.z, rs.smoothed_angular.x, rs.smoothed_angular.y, rs.smoothed_angular.z ); } else { int ahead = framenum * GAME_DELAY - ( now - baseline ); assert( ahead > 0 ); printf( "game sleep %d ms\n", ahead ); SDL_Delay( ahead ); } char * cmd = zstr_recv_nowait( gs.zmq_control_socket ); if ( cmd != NULL ) { assert( strcmp( cmd, "stop" ) == 0 ); free( cmd ); break; } } return 0; }
int socket_connect(void *socket, const char *format, ...) { va_list args; int err, n; char buf[255], id[255]; //zsocket_set_router_mandatory(socket, 1); va_start(args, format); //** Set the ID snprintf(buf, 255, format, args); // snprintf(id, 255, "%s:%ld", buf, random()); snprintf(id, 255, "%ld", random_int(1, 1000)); zsocket_set_identity(socket, strdup(id)); err = zsocket_connect(socket, format, args); n = errno; va_end(args); log_printf(0, "id=!%s! err=%d errno=%d\n", id, err, n); assert(err == 0); return(err); }
int main(int argc, const char **argv){ zctx_t *ctx = zctx_new(); void *sub = zsocket_new(ctx, ZMQ_SUB); zsocket_set_subscribe(sub, ""); zsocket_connect(sub, "tcp://127.0.0.1:3000"); printf("connected to :3000\n"); struct timeval start; gettimeofday(&start, NULL); while (1) { char *msg = zstr_recv(sub); if (0 == n--) { struct timeval end; gettimeofday(&end, NULL); int duration = end.tv_sec - start.tv_sec; printf("\n"); printf(" pub/sub:\n"); printf(" %d msgs\n", ops); printf(" %d ops/s\n", ops / duration); printf(" %d s\n", duration); printf("\n"); exit(0); } } return 0; }
static void* worker_routine(void* arg) { zmsg_t* msg; zframe_t* frame; zctx_t* ctx = zctx_new(); void* worker = zsocket_new(ctx, ZMQ_REQ); zsocket_connect(worker, "ipc://%s-localbe.ipc", self); frame = zframe_new(WORKER_READY, 1); zframe_send(&frame, worker, 0); while (1) { msg = zmsg_recv(worker); if (!msg) break; zframe_print(zmsg_last(msg), "Worker: "); zframe_reset(zmsg_last(msg), "OK", 2); zmsg_send(&msg, worker); } zctx_destroy(&ctx); return NULL; }
void * zthread_fork (zctx_t *ctx, zthread_attached_fn *thread_fn, void *args) { shim_t *shim = NULL; // Create our end of the pipe void *pipe = zctx__socket_pipe (ctx); assert (pipe); zsocket_bind (pipe, "inproc://zctx-pipe-%p", pipe); // Prepare argument shim for child thread shim = (shim_t *) zmalloc (sizeof (shim_t)); assert (shim); shim->attached = thread_fn; shim->args = args; shim->ctx = zctx_shadow (ctx); assert (shim->ctx); shim->pipe = zctx__socket_pipe (shim->ctx); assert (shim->pipe); // Connect child pipe to our pipe zsocket_connect (shim->pipe, "inproc://zctx-pipe-%p", pipe); s_thread_start (shim); return pipe; }
static agent_t * s_agent_new (zctx_t *ctx, void *control) { agent_t *self = (agent_t *) zmalloc (sizeof (agent_t)); self->ctx = ctx; self->control = control; self->router = zsocket_new (ctx, ZMQ_ROUTER); // Connect our data socket to caller's endpoint self->data = zsocket_new (ctx, ZMQ_PAIR); char *endpoint = zstr_recv (self->control); int rc = zsocket_connect (self->data, "%s", endpoint); assert (rc != -1); free (endpoint); // Create new client codec using cert from API byte public_key [32]; byte secret_key [32]; rc = zmq_recv (self->control, public_key, 32, 0); assert (rc == 32); rc = zmq_recv (self->control, secret_key, 32, 0); assert (rc == 32); self->cert = zcert_new_from (public_key, secret_key); self->metadata = zhash_new (); zhash_autofree (self->metadata); self->clients = zhash_new (); self->max_clients = 100; self->max_pending = 10; self->client_ttl = 3600; // 60 minutes self->pending_ttl = 60; // 60 seconds return self; }
static void * client_task (void *args) { zctx_t *ctx = zctx_new (); void *client = zsocket_new (ctx, ZMQ_DEALER); // Set random identity to make tracing easier char identity [10]; sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000)); zsocket_set_identity (client, identity); zsocket_connect (client, "tcp://localhost:5570"); zmq_pollitem_t items [] = { { client, 0, ZMQ_POLLIN, 0 } }; int request_nbr = 0; while (true) { // Tick once per second, pulling in arriving messages int centitick; for (centitick = 0; centitick < 100; centitick++) { zmq_poll (items, 1, 10 * ZMQ_POLL_MSEC); if (items [0].revents & ZMQ_POLLIN) { zmsg_t *msg = zmsg_recv (client); zframe_print (zmsg_last (msg), identity); zmsg_destroy (&msg); } } zstr_send (client, "request #%d"); } zctx_destroy (&ctx); return NULL; }
static void test_zmq (flux_reactor_t *reactor) { zctx_t *zctx; void *zs[2]; flux_watcher_t *r, *w; ok ((zctx = zctx_new ()) != NULL, "zmq: created zmq context"); zs[0] = zsocket_new (zctx, ZMQ_PAIR); zs[1] = zsocket_new (zctx, ZMQ_PAIR); ok (zs[0] && zs[1] && zsocket_bind (zs[0], "inproc://test_zmq") == 0 && zsocket_connect (zs[1], "inproc://test_zmq") == 0, "zmq: connected ZMQ_PAIR sockets over inproc"); r = flux_zmq_watcher_create (reactor, zs[0], FLUX_POLLIN, zmqreader, NULL); w = flux_zmq_watcher_create (reactor, zs[1], FLUX_POLLOUT, zmqwriter, NULL); ok (r != NULL && w != NULL, "zmq: nonblocking reader and writer created"); flux_watcher_start (r); flux_watcher_start (w); ok (flux_reactor_run (reactor, 0) == 0, "zmq: reactor ran to completion after %d messages", zmqwriter_msgcount); flux_watcher_stop (r); flux_watcher_stop (w); flux_watcher_destroy (r); flux_watcher_destroy (w); zsocket_destroy (zctx, zs[0]); zsocket_destroy (zctx, zs[1]); zctx_destroy (&zctx); }
int main (void) { zctx_t *ctx = zctx_new (); zctx_set_linger (ctx, 1000); void *pub = zsocket_new (ctx, ZMQ_XPUB); zsocket_set_hwm (pub, 0); zsocket_connect (pub, "tcp://127.0.0.1:9000"); // Wait for subscriber to subscribe zframe_t *frame = zframe_recv (pub); zframe_destroy (&frame); // Send HELLOs for five seconds size_t total = 0; int64_t finish_at = zclock_time () + 5000; while (zclock_time () < finish_at) { // Send 100K and then check time again int count = 0; for (count = 0; count < 100000; count++) zstr_send (pub, "HELLO"); total++; } printf ("%zd00000 messages sent\n", total); zstr_send (pub, "WORLD"); zctx_destroy (&ctx); return 0; }
void collabclient_closeLocalServer( int port ) { #ifdef BUILD_COLLAB collabclient_sniffForLocalServer_t* cc = &collabclient_sniffForLocalServer_singleton; zctx_t* ctx = obtainMainZMQContext(); int beacon_port = port; if( !port ) port = collabclient_getDefaultBasePort(); printf("collabclient_closeLocalServer() port:%d\n", port); void* socket = zsocket_new ( ctx, ZMQ_REQ ); zsocket_connect ( socket, "tcp://localhost:%d", port+socket_offset_ping); zstr_send( socket, "quit" ); cc->haveServer = 0; if( beacon_port ) { g_hash_table_remove_all( peers ); } collabclient_sniffForLocalServer(); #endif }
int main (int argc, char *argv []) { // Socket to talk to server printf ("Collecting updates from weather server...\n"); zctx_t *context = zctx_new (); void *subscriber = zsocket_new (context, ZMQ_PULL); zsocket_set_hwm(subscriber, 100000); int rc = zsocket_connect (subscriber, RECEIVE_SOCKET); assert (rc == 0); void *worker = zsocket_new(context, ZMQ_PUSH); rc = zsocket_bind(worker, WORKER_SOCKET); assert(rc == 0); int nthreads = 0; for (nthreads=0; nthreads < 50; nthreads++) { zthread_fork(context, parser_thread, NULL); } // Subscribe to zipcode, default is NYC, 10001 while(1) { int size; char *string = safe_recv_from_server (subscriber, &size); parse_notifications(string, size, worker); free (string); } printf("Ending \n"); zctx_destroy (&context); return 0; }
void send_czmq (char *buf, int len) { zctx_t *zctx; void *zs; zmsg_t *zmsg; if (!(zctx = zctx_new ())) log_err_exit ("C: zctx_new"); if (lopt) /* zctx linger default = 0 (flush none) */ zctx_set_linger (zctx, linger); if (!(zs = zsocket_new (zctx, ZMQ_DEALER))) log_err_exit ("C: zsocket_new"); //if (lopt) // doesn't work here // zsocket_set_linger (zs, linger); if (iopt) zsocket_set_immediate (zs, imm); //zsocket_set_sndhwm (zs, 0); /* unlimited */ if (zsocket_connect (zs, "%s", uri) < 0) log_err_exit ("C: zsocket_connect"); if (!(zmsg = zmsg_new ())) oom (); if (zmsg_pushmem (zmsg, buf, bufsize) < 0) oom (); if (zmsg_send (&zmsg, zs) < 0) log_err_exit ("C: zmsg_send"); if (sleep_usec > 0) usleep (sleep_usec); zctx_destroy (&zctx); }
static agent_t * s_agent_new (zctx_t *ctx, void *control) { agent_t *self = (agent_t *) zmalloc (sizeof (agent_t)); self->ctx = ctx; self->control = control; self->state = waiting; self->dealer = zsocket_new (ctx, ZMQ_DEALER); // Connect our data socket to caller's endpoint self->data = zsocket_new (ctx, ZMQ_PAIR); char *endpoint = zstr_recv (self->control); int rc = zsocket_connect (self->data, "%s", endpoint); assert (rc != -1); free (endpoint); // Create new client codec using cert from API byte public_key [32]; byte secret_key [32]; rc = zmq_recv (self->control, public_key, 32, 0); assert (rc == 32); rc = zmq_recv (self->control, secret_key, 32, 0); assert (rc == 32); zcert_t *cert = zcert_new_from (public_key, secret_key); self->codec = curve_codec_new_client (cert); zcert_destroy (&cert); return self; }
void * zthread_fork (zctx_t *ctx, zthread_attached_fn *thread_fn, void *args) { shim_t *shim = NULL; // Create our end of the pipe void *pipe = zsocket_new (ctx, ZMQ_PAIR); if (pipe) { zsocket_set_hwm (pipe, zctx_hwm (ctx)); zsocket_bind (pipe, "inproc://zctx-pipe-%p", pipe); } else return NULL; // Prepare argument shim for child thread shim = (shim_t *) zmalloc (sizeof (shim_t)); if (shim) { shim->attached = thread_fn; shim->args = args; shim->ctx = zctx_shadow (ctx); if (!shim->ctx) return NULL; } else return NULL; // Connect child pipe to our pipe shim->pipe = zsocket_new (shim->ctx, ZMQ_PAIR); if (!shim->pipe) return NULL; zsocket_set_hwm (shim->pipe, 1); zsocket_connect (shim->pipe, "inproc://zctx-pipe-%p", pipe); s_thread_start (shim); return pipe; }
int main (int argc, char *argv []) { zctx_t *context = zctx_new (); void *publisher = zsocket_new (context, ZMQ_PUB); if (argc == 2) zsocket_connect (publisher, argv [1]); else zsocket_bind (publisher, "tcp://*:5556"); // Ensure subscriber connection has time to complete sleep (1); // Send out all 1,000 topic messages int topic_nbr; for (topic_nbr = 0; topic_nbr < 1000; topic_nbr++) { zstr_sendm (publisher, "%03d", topic_nbr, ZMQ_SNDMORE); zstr_send (publisher, "Save Roger"); } // Send one random update per second srandom ((unsigned) time (NULL)); while (!zctx_interrupted) { sleep (1); zstr_sendm (publisher, "%03d", randof (1000), ZMQ_SNDMORE); zstr_send (publisher, "Off with his head!"); } zctx_destroy (&context); return 0; }
bstar_t * bstar_new (int primary, char *local, char *remote) { bstar_t *self; self = (bstar_t *) zmalloc (sizeof (bstar_t)); // Initialize the Binary Star self->ctx = zctx_new (); self->loop = zloop_new (); self->state = primary? STATE_PRIMARY: STATE_BACKUP; // Create publisher for state going to peer self->statepub = zsocket_new (self->ctx, ZMQ_PUB); zsocket_bind (self->statepub, local); // Create subscriber for state coming from peer self->statesub = zsocket_new (self->ctx, ZMQ_SUB); zsocket_set_subscribe (self->statesub, ""); zsocket_connect (self->statesub, remote); // Set-up basic reactor events zloop_timer (self->loop, BSTAR_HEARTBEAT, 0, s_send_state, self); zmq_pollitem_t poller = { self->statesub, 0, ZMQ_POLLIN }; zloop_poller (self->loop, &poller, s_recv_state, self); return self; }
static void server_worker (void *args, zctx_t *ctx, void *pipe) { void *worker = zsocket_new (ctx, ZMQ_DEALER); zsocket_connect (worker, "inproc://backend"); while (true) { // The DEALER socket gives us the reply envelope and message zmsg_t *msg = zmsg_recv (worker); zframe_t *identity = zmsg_pop (msg); zframe_t *content = zmsg_pop (msg); assert (content); zmsg_destroy (&msg); // Send 0..4 replies back int reply, replies = randof (5); for (reply = 0; reply < replies; reply++) { // Sleep for some fraction of a second zclock_sleep (randof (1000) + 1); zframe_send (&identity, worker, ZFRAME_REUSE + ZFRAME_MORE); zframe_send (&content, worker, ZFRAME_REUSE); } zframe_destroy (&identity); zframe_destroy (&content); } }
// Checks whether client can connect to server static bool s_can_connect (zctx_t *ctx, void **server, void **client) { int port_nbr = zsocket_bind (*server, "tcp://127.0.0.1:*"); assert (port_nbr > 0); int rc = zsocket_connect (*client, "tcp://127.0.0.1:%d", port_nbr); assert (rc == 0); // Give the connection time to fail if that's the plan zclock_sleep (200); // By default PUSH sockets block if there's no peer zsock_set_sndtimeo (*server, 200); zstr_send (*server, "Hello, World"); zpoller_t *poller = zpoller_new (*client, NULL); bool success = (zpoller_wait (poller, 400) == *client); zpoller_destroy (&poller); zsocket_destroy (ctx, *client); zsocket_destroy (ctx, *server); *server = zsocket_new (ctx, ZMQ_PUSH); assert (*server); *client = zsocket_new (ctx, ZMQ_PULL); assert (*client); return success; }
void * zthread_fork (zctx_t *ctx, zthread_attached_fn *thread_fn, void *args) { // Create our end of the pipe // Pipe has HWM of 1 at both sides to block runaway writers void *pipe = zsocket_new (ctx, ZMQ_PAIR); assert (pipe); zsockopt_set_hwm (pipe, 1); zsocket_bind (pipe, "inproc://zctx-pipe-%p", pipe); // Prepare argument shim for child thread shim_t *shim = (shim_t *) zmalloc (sizeof (shim_t)); shim->attached = thread_fn; shim->args = args; shim->ctx = zctx_shadow (ctx); // Connect child pipe to our pipe shim->pipe = zsocket_new (shim->ctx, ZMQ_PAIR); assert (shim->pipe); zsockopt_set_hwm (shim->pipe, 1); zsocket_connect (shim->pipe, "inproc://zctx-pipe-%p", pipe); s_thread_start (shim); return pipe; }
static void client_task (void *args, zctx_t *ctx, void *pipe) { void *client = zsocket_new (ctx, ZMQ_DEALER); zsocket_connect (client, "tcp://localhost:5555"); printf ("Setting up test...\n"); zclock_sleep (100); int requests; int64_t start; printf ("Synchronous round-trip test...\n"); start = zclock_time (); for (requests = 0; requests < 10000; requests++) { zstr_send (client, "hello"); char *reply = zstr_recv (client); free (reply); } printf (" %d calls/second\n", (1000 * 10000) / (int) (zclock_time () - start)); printf ("Asynchronous round-trip test...\n"); start = zclock_time (); for (requests = 0; requests < 100000; requests++) zstr_send (client, "hello"); for (requests = 0; requests < 100000; requests++) { char *reply = zstr_recv (client); free (reply); } printf (" %d calls/second\n", (1000 * 100000) / (int) (zclock_time () - start)); zstr_send (pipe, "done"); }
static void* client_routine(void* arg) { zctx_t* ctx = zctx_new(); void* client = zsocket_new(ctx, ZMQ_REQ); zsocket_connect(client, "ipc://frontend.ipc"); while (1) { char* reply; zstr_send(client, "Hello"); reply = zstr_recv(client); if (NULL == reply) break; fprintf(stdout, "client: %s\n", reply); free(reply); sleep(1); } zctx_destroy(&ctx); return NULL; }
static bool s_can_connect (void *server, void *client) { // We'll do each test on a new port number since otherwise we have to // destroy and recreate the sockets each time. static int port_nbr = 9000; int rc = zsocket_bind (server, "tcp://*:%d", port_nbr); assert (rc == port_nbr); rc = zsocket_connect (client, "tcp://localhost:%d", port_nbr); assert (rc == 0); zpoller_t *poller = zpoller_new (client, NULL); zstr_send (server, "Hello, World"); // Need up to half a second if running under Valgrind bool success = zpoller_wait (poller, 500) == client; if (success) free (zstr_recv (client)); zpoller_destroy (&poller); rc = zsocket_unbind (server, "tcp://*:%d", port_nbr); assert (rc != -1); rc = zsocket_disconnect (client, "tcp://localhost:%d", port_nbr); assert (rc != -1); port_nbr++; return success; }
void zre_peer_connect (zre_peer_t *self, char *reply_to, char *endpoint) { assert (self); assert (!self->connected); // Create new outgoing socket (drop any messages in transit) self->mailbox = zsocket_new (self->ctx, ZMQ_DEALER); // Set our caller 'From' identity so that receiving node knows // who each message came from. zsocket_set_identity (self->mailbox, reply_to); // Set a high-water mark that allows for reasonable activity zsocket_set_sndhwm (self->mailbox, PEER_EXPIRED * 100); // Send messages immediately or return EAGAIN zsocket_set_sndtimeo (self->mailbox, 0); // Connect through to peer node zsocket_connect (self->mailbox, "tcp://%s", endpoint); self->endpoint = strdup (endpoint); self->connected = true; self->ready = false; }
explicit Streamer(int i) : socket_(nullptr) , backendSocket_(nullptr) , id_("Streamer" + std::to_string(i)) { socket_ = zsocket_new(ctx_, ZMQ_DEALER); assert(socket_); //zsock_set_identity((zsock_t*)socket_, id_.c_str()); int rc = zsocket_connect(socket_, "tcp://127.0.0.1:5562"); assert(rc); backendSocket_ = zsocket_new(ctx_, ZMQ_DEALER); assert(backendSocket_); //zsock_set_identity((zsock_t*)backendSocket_, id_.c_str()); rc = zsocket_connect(backendSocket_, "tcp://127.0.0.1:5563"); assert(rc); }
int zsocket_test (Bool verbose) { printf (" * zsocket: "); // @selftest zctx_t *ctx = zctx_new (); assert (ctx); // Create a detached thread, let it run char *interf = "*"; char *domain = "localhost"; int service = 5560; void *writer = zsocket_new (ctx, ZMQ_PUSH); assert (writer); void *reader = zsocket_new (ctx, ZMQ_PULL); assert (reader); assert (streq (zsocket_type_str (writer), "PUSH")); assert (streq (zsocket_type_str (reader), "PULL")); int rc = zsocket_bind (writer, "tcp://%s:%d", interf, service); assert (rc == service); rc = zsocket_connect (reader, "tcp://%s:%d", domain, service); assert (rc == 0); zstr_send (writer, "HELLO"); char *message = zstr_recv (reader); assert (message); assert (streq (message, "HELLO")); free (message); int port = zsocket_bind (writer, "tcp://%s:*", interf); assert (port >= ZSOCKET_DYNFROM && port <= ZSOCKET_DYNTO); assert (zsocket_poll (writer, 100) == FALSE); rc = zsocket_connect (reader, "txp://%s:%d", domain, service); assert (rc == -1); zsocket_destroy (ctx, writer); zctx_destroy (&ctx); // @end printf ("OK\n"); return 0; }