int main(){
void* context = zmq_init(1);
void* receiver = zmq_socket(context, ZMQ_PULL);
zmq_bind(receiver, "tcp://*:5558");
//wait for start of batch
char *string = s_recv(receiver);
free(string);
//start clock
int64_t start_time = s_clock();
//process 100
int tasks_nbr;
for( tasks_nbr = 0; tasks_nbr < 100; tasks_nbr++){
char* string = s_recv(receiver);
if((tasks_nbr / 10)*10 == tasks_nbr){
printf(":");
} else{
printf(".");
}
fflush(stdout);
}
printf("Total elapsed time: %d msec\n",
(int)(s_clock() - start_time));
zmq_close(receiver);
zmq_term(context);
return 0;
}
static void *
worker_task (void *args)
{
void *context = zmq_ctx_new ();
void *worker = zmq_socket (context, ZMQ_REQ);
s_set_id (worker); // Set a printable identity
zmq_connect (worker, "ipc://backend.ipc");
// Tell broker we're ready for work
s_send (worker, "READY");
while (1) {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
char *identity = s_recv (worker);
char *empty = s_recv (worker);
assert (*empty == 0);
free (empty);
// Get request, send reply
char *request = s_recv (worker);
printf ("Worker: %s\n", request);
free (request);
s_sendmore (worker, identity);
s_sendmore (worker, "");
s_send (worker, "OK");
free (identity);
}
zmq_close (worker);
zmq_ctx_destroy (context);
return NULL;
}
// Worker using REQ socket to do LRU routing
//
static void *
worker_thread (void *arg) {
zmq::context_t context(1);
zmq::socket_t worker (context, ZMQ_REQ);
s_set_id (worker); // Makes tracing easier
worker.connect("ipc://backend.ipc");
// Tell backend we're ready for work
s_send (worker, "READY");
while (1) {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
std::string address = s_recv (worker);
{
std::string empty = s_recv (worker);
assert (empty.size() == 0);
}
// Get request, send reply
std::string request = s_recv (worker);
std::cout << "Worker: " << request << std::endl;
s_sendmore (worker, address);
s_sendmore (worker, "");
s_send (worker, "OK");
}
return (NULL);
}
int main(int argc, char* argv[]) {
zmq::context_t context(1);
zmq::socket_t subscriber(context, ZMQ_SUB);
subscriber.connect("tcp://localhost:5561");
subscriber.setsockopt(ZMQ_SUBSCRIBE, "", 0);
zmq::socket_t syncclient(context, ZMQ_REQ);
syncclient.connect("tcp://localhost:5562");
s_send(syncclient, "");
s_recv(syncclient);
std::cout << "Connected to subscriber" << std::endl;
int update_nbr = 0;
while(1) {
if (s_recv(subscriber).compare("END") == 0) {
std::cout << "FINE" << std::endl;
break;
}
update_nbr++;
}
std::cout << "Received " << update_nbr << "updates" << std::endl;
return 0;
}
// Worker using REQ socket to do LRU routing
//
static void *
worker_thread (void *args) {
void *context = zmq_init (1);
void *worker = zmq_socket (context, ZMQ_REQ);
s_set_id (worker); // Makes tracing easier
zmq_connect (worker, "ipc://backend.ipc");
// Tell broker we're ready for work
s_send (worker, "READY");
while (1) {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
char *address = s_recv (worker);
char *empty = s_recv (worker);
assert (*empty == 0);
free (empty);
// Get request, send reply
char *request = s_recv (worker);
printf ("Worker: %s\n", request);
free (request);
s_sendmore (worker, address);
s_sendmore (worker, "");
s_send (worker, "OK");
free (address);
}
zmq_close (worker);
zmq_term (context);
return NULL;
}
void str_recv_from (void *s_, char **ptr_content_, char **ptr_address_)
{
*ptr_address_ = s_recv (s_);
assert (ptr_address_);
*ptr_content_ = s_recv (s_);
assert (ptr_content_);
}
int
main (void)
{
void *context;
void *subscriber1;
void *subscriber2;
char *filter;
int i;
int ok;
context = zmq_ctx_new ();
subscriber1 = zmq_socket (context, ZMQ_SUB);
printf ("connecting...\n");
ok = zmq_connect (subscriber1, "tcp://localhost:5000");
assert (ok == 0);
subscriber2 = zmq_socket (context, ZMQ_SUB);
ok = zmq_connect (subscriber2, "tcp://localhost:5001");
assert (ok == 0);
printf ("connected.\n");
printf ("set filters...\n");
filter = "filter1";
ok = zmq_setsockopt (subscriber1,
ZMQ_SUBSCRIBE,
filter,
strlen (filter));
assert (ok == 0);
filter = "filter2";
ok = zmq_setsockopt (subscriber2,
ZMQ_SUBSCRIBE,
filter,
strlen (filter));
assert (ok == 0);
printf ("filters set.\n");
printf ("receiving messages...\n");
for (i = 0; i < 3; i++)
{
char *msg = s_recv (subscriber1);
printf ("%s\n", msg);
free (msg);
}
for (i = 0; i < 3; i++)
{
char *msg = s_recv (subscriber2);
printf ("%s\n", msg);
free (msg);
}
zmq_close (subscriber1);
zmq_close (subscriber2);
zmq_ctx_destroy (context);
return 0;
}
int main(int argc, char *argv[])
{
void *ctx, *handler, *thread, *server, *client;
const char *domain, *connect_addr;
int optval;
domain = argc > 1 ? argv[1] : "test";
connect_addr = strcmp(domain, "fail") ? "tcp://127.0.0.1:9000" : "tcp://127.0.0.1:9001";
assert((ctx = zmq_ctx_new()));
/* Start ZAP handler thread. */
assert((handler = zmq_socket(ctx, ZMQ_REP)));
assert(!(zmq_bind(handler, "inproc://zeromq.zap.01")));
assert((thread = zmq_threadstart(zap_handler, handler)));
/* Bind server. */
assert((server = zmq_socket(ctx, ZMQ_DEALER)));
assert(!(zmq_setsockopt(server, ZMQ_ZAP_DOMAIN, domain, strlen(domain))));
assert(!zmq_bind(server, "tcp://127.0.0.1:9000"));
/* Connect client. */
assert((client = zmq_socket(ctx, ZMQ_DEALER)));
optval = 200;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL, &optval, sizeof(optval))));
optval = 5000;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL_MAX, &optval, sizeof(optval))));
optval = 30000;
assert(!(zmq_setsockopt(client, ZMQ_SNDTIMEO, &optval, sizeof(optval))));
optval = 1;
assert(!(zmq_setsockopt(client, ZMQ_IMMEDIATE, &optval, sizeof(optval))));
assert(!zmq_connect(client, connect_addr));
/* Bounce test. */
s_send(client, "Hello, Server!");
assert(!strcmp(s_recv(server), "Hello, Server!"));
s_send(server, "Hello, Client!");
assert(!strcmp(s_recv(client), "Hello, Client!"));
/* Cleanup. */
assert(!zmq_disconnect(client, connect_addr));
assert(!zmq_close(client));
assert(!zmq_unbind(server, "tcp://127.0.0.1:9000"));
assert(!zmq_close(server));
assert(!zmq_term(ctx));
zmq_threadclose(thread);
return 0;
}
// pubRequest by one of the Satellites, this Server just forwards it by publishing it
bool ReefServer::pubRequest(RMessage& msg){
msg = RMessage();
bool retBool;
std::string tagsStr = s_recv(rep); //receive message tags
std::string bodyStr = s_recv(rep); //receive messagebody
CJsonArray tagsArray = jsonToArray(tagsStr); //parse Tags
tagsInitMessage(msg, tagsArray); //initiate msg with the tags
tagsArray.Clear();
retBool = checkInterestAndProcess(msg, bodyStr);
s_sendmore(publisher, ""); //send empty envelope
s_sendmore(publisher, tagsStr); //receive tag-part of message and publish it
s_send(publisher, bodyStr); //receive body-part of message and publish it
return retBool;
}
int main(void)
{
//Create ZMQ Socket
void *context = zmq_ctx_new();
//Socket to receive messages
void *receiver = zmq_socket(context, ZMQ_PULL);
zmq_bind(receiver, "tcp://*:5558");
//Socket to control workers
void *controller = zmq_socket(context, ZMQ_PUB);
zmq_bind(controller, "tcp://*:5559");
//Waiting for start
char *string = s_recv(receiver);
free(string);
//Start clock
int64_t start_time = s_clock();
//Process messages
int task_nbr;
for(task_nbr = 0; task_nbr < 100; task_nbr++)
{
char *string = s_recv(receiver);
free(string);
if((task_nbr / 10) * 10 == task_nbr)
{
printf(":");
}
else
{
printf(".");
}
fflush(stdout);
}
printf("Total elapsed time: %d msec\n", (int)(s_clock()-start_time));
//Send Kille signal
s_send(controller, "KILL");
zmq_close(receiver);
zmq_close(controller);
zmq_ctx_destroy(context);
return 0;
}
static void *
worker_thread (void *arg) {
zmq::context_t * context = (zmq::context_t *)arg;
zmq::socket_t worker (*context, ZMQ_REQ);
// We use a string identity for ease here
s_set_id (worker);
worker.connect("ipc://routing.ipc");
int total = 0;
while (1) {
// Tell the router we're ready for work
s_send (worker, "ready");
// Get workload from router, until finished
std::string workload = s_recv (worker);
int finished = (workload.compare("END") == 0);
if (finished) {
std::cout << "Processed: " << total << " tasks" << std::endl;
break;
}
total++;
// Do some random work
s_sleep(within (100) + 1);
}
return (NULL);
}
int main (int argc, char *argv [])
{
// Socket to talk to server
printf ("Collecting updates from weather server…\n");
void *context = zmq_ctx_new ();
void *subscriber = zmq_socket (context, ZMQ_SUB);
int rc = zmq_connect (subscriber, "tcp://localhost:5556");
assert (rc == 0);
// Subscribe to zipcode, default is NYC, 10001
char *filter = (argc > 1)? argv [1]: "10001 ";
rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,
filter, strlen (filter));
assert (rc == 0);
// Process 100 updates
int update_nbr;
long total_temp = 0;
for (update_nbr = 0; update_nbr < 100; update_nbr++) {
char *string = s_recv (subscriber);
int zipcode, temperature, relhumidity;
sscanf (string, "%d %d %d",
&zipcode, &temperature, &relhumidity);
total_temp += temperature;
free (string);
}
printf ("Average temperature for zipcode '%s' was %dF\n",
filter, (int) (total_temp / update_nbr));
zmq_close (subscriber);
zmq_ctx_destroy (context);
return 0;
}
void test_plain_vanilla_socket ()
{
// Unauthenticated messages from a vanilla socket shouldn't be received
struct sockaddr_in ip4addr;
fd_t s;
unsigned short int port;
int rc = sscanf (my_endpoint, "tcp://127.0.0.1:%hu", &port);
TEST_ASSERT_EQUAL_INT (1, rc);
ip4addr.sin_family = AF_INET;
ip4addr.sin_port = htons (port);
#if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)
ip4addr.sin_addr.s_addr = inet_addr ("127.0.0.1");
#else
inet_pton (AF_INET, "127.0.0.1", &ip4addr.sin_addr);
#endif
s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
TEST_ASSERT_GREATER_THAN_INT (-1, rc);
// send anonymous ZMTP/1.0 greeting
send (s, "\x01\x00", 2, 0);
// send sneaky message that shouldn't be received
send (s, "\x08\x00sneaky\0", 9, 0);
int timeout = 250;
zmq_setsockopt (server, ZMQ_RCVTIMEO, &timeout, sizeof (timeout));
char *buf = s_recv (server);
if (buf != NULL) {
printf ("Received unauthenticated message: %s\n", buf);
TEST_ASSERT_NULL (buf);
}
close (s);
}
int main(void)
{
void *context = zmq_ctx_new();
void *socket = zmq_socket(context, ZMQ_REP);
zmq_bind(socket, "tcp://*:5555");
s_catch_signals();
#if 1
while (1) {
// Blocking read will exit on a signal
char buffer[255];
zmq_recv(socket, buffer, 255, 0);
if (s_interrupted) {
printf("W: interrupt received, killing server...\n");
break;
}
}
#else
while (!s_interrupted) {
char *message = s_recv(socket);
if (!message) {
break;
}
}
#endif
zmq_close(socket);
zmq_ctx_destroy(context);
#ifdef _MSC_VER
system("pause");
#endif
return 0;
}
void replay(void *arg) {
void *slave = zmq_socket(arg, ZMQ_REQ);
/*
if (done % 2) {
zmq_connect (slave, "tcp://localhost:5562");
}
else {
zmq_connect (slave, "tcp://localhost:5563");
}*/
zmq_connect (slave, "tcp://localhost:5562");
char *string;
char buf[1024];
sprintf(buf, "%d", rand());
s_send(slave, buf);
string = s_recv(slave);
if (strcmp(string , buf) != 0) {
debug_puts("ERROR");
}
free(string);
pthread_mutex_lock(&lock);
done++;
pthread_mutex_unlock(&lock);
zmq_close(slave);
}
int main (void)
{
void *context = zmq_ctx_new ();
// Socket to talk to clients
void *responder = zmq_socket (context, ZMQ_REP);
zmq_connect (responder, "tcp://localhost:5560");
while (true) {
// Wait for next request from client
char *string = s_recv (responder);
printf ("Received request: [%s]\n", string);
free (string);
// Do some 'work'
sleep (1);
// Send reply back to client
s_send (responder, "World");
}
// We never get here but clean up anyhow
zmq_close (responder);
zmq_ctx_destroy (context);
return 0;
}
int main ()
{
srand ((unsigned) time (NULL));
zmq::context_t context(1);
zmq::socket_t server(context, ZMQ_REP);
server.bind("tcp://*:5555");
int cycles = 0;
while (1) {
std::string request = s_recv (server);
cycles++;
// Simulate various problems, after a few cycles
if (cycles > 3 && within (3) == 0) {
std::cout << "I: simulating a crash" << std::endl;
break;
}
else
if (cycles > 3 && within (3) == 0) {
std::cout << "I: simulating CPU overload" << std::endl;
s_sleep (2000);
}
std::cout << "I: normal request (" << request << ")" << std::endl;
s_sleep (1000); // Do some heavy work
s_send (server, request);
}
return 0;
}
int main () {
zmq::context_t context(1);
// Subscriber tells us when it's ready here
zmq::socket_t sync(context, ZMQ_PULL);
sync.bind("tcp://*:5564");
// We send updates via this socket
zmq::socket_t publisher (context, ZMQ_PUB);
publisher.bind("tcp://*:5565");
// Wait for synchronization request
s_recv (sync);
// Now broadcast exactly 10 updates with pause
int update_nbr;
for (update_nbr = 0; update_nbr < 10; update_nbr++) {
std::ostringstream oss;
oss << "Update "<< update_nbr ;
s_send (publisher, oss.str());
sleep (1);
}
s_send (publisher, "END");
sleep (1); // Give 0MQ/2.0.x time to flush output
return 0;
}
int main()
{
// Socket to receive messages on
void *context = zmq_ctx_new();
void *receiver = zmq_socket(context, ZMQ_PULL);
zmq_connect(receiver, "tcp://localhost:5557");
// Socket to send messages to
void *sender = zmq_socket(context, ZMQ_PUSH);
zmq_connect(sender, "tcp://localhost:5558");
// Process tasks forever
while (1)
{
char *string = s_recv(receiver);
printf("%s.", string); // Show progress
fflush(stdout);
s_sleep(atoi(string)); // Do the work
free(string);
s_send(sender, ""); // Send results to sink
}
zmq_close(receiver);
zmq_close(sender);
zmq_ctx_destroy(context);
return 0;
}
int main()
{
void *context = zmq_ctx_new();
if (NULL == context)
{
printf("aaa\n");
}
void *sender = zmq_socket(context, ZMQ_PULL);
if (NULL == sender)
{
printf("aaa\n");
}
unsigned int i;
char url[256];
sprintf(url, "tcp://127.0.0.1:5557");
zmq_connect(sender, url);
for(i=0; ; i++)
{
char *temp = s_recv(sender);
if (strcmp(temp, "exit") == 0)
break;
//printf("buff: %s", temp);
}
zmq_close(sender);
zmq_ctx_destroy(context);
}
int main (void)
{
printf ("Connecting to math server…\n");
void *context = zmq_ctx_new ();
void *requester = zmq_socket (context, ZMQ_REQ);
zmq_connect (requester, "tcp://localhost:5555");
srand(time(NULL));
int request_nbr;
for (request_nbr = 0; request_nbr < 1000; request_nbr++) {
char buffer [10];
int a = randof(30);
int b = randof(30);
printf ("Sending (%d, %d)…\n", a, b);
char to_send[100];
sprintf(to_send, "%d %d", a, b);
s_send(requester, to_send);
char* ret = s_recv(requester);
int sum = atoi(ret);
printf("%d + %d = %d\n", a, b, sum);
free(ret);
}
zmq_close (requester);
zmq_ctx_destroy (context);
return 0;
}
int main (void)
{
void *context = zmq_init (1);
// Connect our subscriber socket
void *subscriber = zmq_socket (context, ZMQ_SUB);
zmq_setsockopt (subscriber, ZMQ_IDENTITY, "Hello", 5);
zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "", 0);
zmq_connect (subscriber, "tcp://localhost:5565");
// Synchronize with publisher
void *sync = zmq_socket (context, ZMQ_PUSH);
zmq_connect (sync, "tcp://localhost:5564");
s_send (sync, "");
// Get updates, expect random Ctrl-C death
while (1) {
char *string = s_recv (subscriber);
printf ("%s\n", string);
if (strcmp (string, "END") == 0) {
free (string);
break;
}
free (string);
}
zmq_close (subscriber);
zmq_term (context);
return 0;
}
int main (void)
{
std::cout << "starting client..."<<std::endl;
// Prepare our context and socket
context = new zmq::context_t(1);
socket = new zmq::socket_t(*context, ZMQ_REQ);
std::cout << "Connecting to hello world server…" << std::endl;
try {
socket->connect ("tcp://localhost:5555");
}
catch (zmq::error_t error) {
std::cout << "Error connecting to address " << std::endl;
std::cout << error.what();
cleanUp();
exit(1);
}
// Do 10 requests, waiting each time for a response
for (int request_nbr = 0; request_nbr != 10; request_nbr++) {
// ask for the depth map
s_send(*socket, "getDepthmap");
// receive result
std::string requestResult = s_recv(*socket);
uint8_t *depthMap = (uint8_t *) strdup(requestResult.c_str());
}
cleanUp();
return 0;
}
int main (void)
{
s_version_assert (2, 1);
void *context = zmq_init (1);
// Socket to talk to clients
void *publisher = zmq_socket (context, ZMQ_PUB);
zmq_bind (publisher, "tcp://*:5561");
// Socket to receive signals
void *syncservice = zmq_socket (context, ZMQ_REP);
zmq_bind (syncservice, "tcp://*:5562");
// Get synchronization from subscribers
int subscribers = 0;
while (subscribers < SUBSCRIBERS_EXPECTED) {
// - wait for synchronization request
char *string = s_recv (syncservice);
free (string);
// - send synchronization reply
s_send (syncservice, "");
subscribers++;
}
// Now broadcast exactly 1M updates followed by END
int update_nbr;
for (update_nbr = 0; update_nbr < 1000000; update_nbr++)
s_send (publisher, "Rhubarb");
s_send (publisher, "END");
zmq_close (publisher);
zmq_close (syncservice);
zmq_term (context);
return 0;
}
int main ()
{
srandom ((unsigned) time (NULL));
zmq::context_t context(1);
zmq::socket_t server(context, ZMQ_REP);
server.bind("tcp://*:5555");
int cycles = 0;
while (1) {
std::string request = s_recv (server);
cycles++;
// Simulate various problems, after a few cycles
if (cycles > 3 && within (3) == 0) {
printf ("I: simulating a crash\n");
break;
}
else
if (cycles > 3 && within (3) == 0) {
printf ("I: simulating CPU overload\n");
sleep (5);
}
printf ("I: normal request (%s)\n", request.c_str());
sleep (1); // Do some heavy work
s_send (server, request);
}
return 0;
}
int
login (void *ctx, char *username, char *ipaddr)
{
assert(ctx);
assert(username);
assert(ipaddr);
assert(strlen(username) > 0);
assert(strlen(ipaddr) > 0);
console_log("Sending login request...\n");
void *sock = zmq_socket(ctx, ZMQ_REQ);
zmq_connect(sock, "tcp://127.0.0.1:5555");
char cmd_msg[250]; //$$ Longer than length will crash
sprintf(cmd_msg, "login\n%s\n%s", username, ipaddr);
int num_bytes_sent = s_send(sock, cmd_msg);
if (num_bytes_sent == -1) {
console_log("Error sending login request\n");
zmq_close(sock);
return -1;
}
console_log("Waiting for login reply...\n");
char *reply_msg = s_recv(sock);
if (reply_msg != NULL) {
console_log("Received reply: '%s'\n", reply_msg);
free(reply_msg);
}
zmq_close(sock);
return 0;
}
int main(int argc, char **argv)
{
threadpool_t *pool;
int i, k, ret=0;
void *slave[SLAVE_NUM];
char *string;
void *context = zmq_init(1);
pthread_mutex_init(&lock, NULL);
pool = threadpool_init(THREAD, QUEUE, 0);
fprintf(stderr, "Pool started with %d threads and "
"queue size of %d\n", THREAD, QUEUE);
if (!pool) {
return -1;
}
for (i = 0; i < 10; i++) {
/*k = i % 2;
if (k!=0 && k!=1) {
ret = -100;
break;
}*/
ret = threadpool_add(pool, &replay, context, 0);
if (ret) {
break;
}
pthread_mutex_lock(&lock);
tasks++;
pthread_mutex_unlock(&lock);
}
fprintf(stderr, "RET: %d Added %d tasks\n", ret, tasks);
while(tasks / 2 > done) {
sleep(1);
}
fprintf(stderr, "Did %d tasks before shutdown\n", done);
fprintf(stderr, "Did %d tasks\n", done);
slave[0] = zmq_socket (context, ZMQ_REQ);
zmq_connect (slave[0], "tcp://localhost:5562");
/*
slave[1] = zmq_socket (context, ZMQ_REQ);
zmq_connect (slave[1], "tcp://localhost:5563");
*/
for (i = 0; i < SLAVE_NUM; i++) {
s_send(slave[i], "END");
string = s_recv(slave[i]);
free(string);
zmq_close(slave[i]);
}
zmq_term(context);
threadpool_destroy(pool, 0);
return 0;
}
int
query_users (void *ctx, char *filter)
{
assert(ctx);
assert(filter);
console_log("Sending query users request...\n");
void *sock = zmq_socket(ctx, ZMQ_REQ);
zmq_connect(sock, "tcp://127.0.0.1:5555");
char cmd_msg[250]; //$$ Longer than length will crash
sprintf(cmd_msg, "users\n%s", filter);
int num_bytes_sent = s_send(sock, cmd_msg);
if (num_bytes_sent == -1) {
console_log("Error sending query users request\n");
zmq_close(sock);
return -1;
}
console_log("Waiting for query users reply...\n");
char *reply_msg = s_recv(sock);
if (reply_msg != NULL) {
console_log("Received reply: '%s'\n", reply_msg);
free(reply_msg);
}
zmq_close(sock);
return 0;
}
int main (int argc, char *argv[])
{
void *context = zmq_init (1);
// Socket to receive messages on
void *receiver = zmq_socket (context, ZMQ_PULL);
zmq_connect (receiver, "tcp://localhost:5557");
// Socket to send messages to
void *sender = zmq_socket (context, ZMQ_PUSH);
zmq_connect (sender, "tcp://localhost:5558");
// Process tasks forever
while (1) {
char *string = s_recv (receiver);
// Simple progress indicator for the viewer
fflush (stdout);
printf ("%s.", string);
// Do the work
struct timespec t = { 0, atoi (string) * 1000000 };
nanosleep (&t, NULL);
free (string);
// Send results to sink
s_send (sender, "");
}
zmq_close (receiver);
zmq_close (sender);
zmq_term (context);
return 0;
}
int main(){
void* context = zmq_init(1);
// socket to receive msgs on: the vent
void* receiver = zmq_socket(context, ZMQ_PULL);
zmq_connect( receiver, "tcp://localhost:5557");
// socket to send msgs to: the sink
void *sender = zmq_socket( context, ZMQ_PUSH);
zmq_connect( sender, "tcp://localhost:5558");
int tasks_received = 0;
//process
while(1) {
char* string = s_recv(receiver);
fflush(stdout);
printf("%s.", string);
//do work
s_sleep(atoi(string));
free(string);
//send results to sink
s_send(sender, "");
tasks_received++;
printf("Task %d got %d tasks\n", getpid(), tasks_received);
}
zmq_close(receiver);
zmq_close(sender);
zmq_term(0);
return 0;
}
