zmq: basic patterns Request-Reply, Publisher-Subscriber, Denvilator-worker-sink.

#include<zmq.h>
#include <string.h>

/*
g++ req-rep-server.cpp -lzmq -g -O0 -o objs/req-rep-server
*/

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* responder = zmq_socket(context, ZMQ_REP);
    zmq_bind(responder, "tcp://*:1990");
    
    while(true){
        zmq_msg_t request;
        zmq_msg_init(&request);
        zmq_msg_recv(&request, responder, 0);
        zmq_msg_close(&request);
        
        zmq_msg_t reply;
        zmq_msg_init_size(&reply, 6);
        memcpy(zmq_msg_data(&reply), "World", 6);
        zmq_msg_send(&reply, responder, 0);
        zmq_msg_close(&reply);
    }
    
    zmq_close(responder);
    zmq_ctx_destroy(context);
    
    return 0;
}

#include <zmq.h>
#include <string.h>
#include <unistd.h>

/*
g++ req-rep-client.cpp -lzmq -g -O0 -o objs/req-rep-client
*/

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* requester = zmq_socket(context, ZMQ_REQ);
    zmq_connect(requester, "tcp://localhost:1990");
    
    for(;;){
        zmq_msg_t request;
        zmq_msg_init_size(&request, 5);
        memcpy(zmq_msg_data(&request), "Hello", 5);
        zmq_msg_send(&request, requester, 0);
        zmq_msg_close(&request);
        
        sleep(1);
        
        zmq_msg_t reply;
        zmq_msg_init(&reply);
        zmq_msg_recv(&reply, requester, 0);
        printf("get reply: %s\n", (char*)zmq_msg_data(&reply));
        zmq_msg_close(&reply);
        
        sleep(1);
    }
    
    zmq_close(requester);
    zmq_ctx_destroy(context);
    
    return 0;
}

/**
g++ pub-sub-publisher.cpp -lzmq -g -O0 -g -o objs/pub-sub-publisher
*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <zmq.h>

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* publisher = zmq_socket(context, ZMQ_PUB);
    zmq_bind(publisher, "tcp://*:1990");
    
    srand(0);
    char* filter = (argc > 1)? argv[1] : (char*)"xxxx ";
    while(true){
        char buf[64];
        snprintf(buf, sizeof(buf), "%s a=%d b=%d c=%d", filter, rand()%1000, rand()%1000, rand()%1000);
        
        zmq_msg_t msg;
        zmq_msg_init_size(&msg, strlen(buf)+1);
        memcpy(zmq_msg_data(&msg), buf, strlen(buf)+1);
        zmq_msg_send(&msg, publisher, 0);
        zmq_msg_close(&msg);
        
        printf("filter=\"%s\", publish message: %s\n", filter, buf);
        sleep(1);
    }
    
    zmq_close(publisher);
    zmq_ctx_destroy(context);
    
    return 0;
}

/**
g++ pub-sub-subscriber.cpp -lzmq -g -O0 -g -o objs/pub-sub-subscriber
*/
#include <stdlib.h>
#include <string.h>
#include <zmq.h>

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* subscriber = zmq_socket(context, ZMQ_SUB);
    zmq_connect(subscriber, "tcp://localhost:1990");
    
    char* filter = (argc > 1)? argv[1] : (char*)"xxxx ";
    zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter));
    
    while(true){
        zmq_msg_t msg;
        zmq_msg_init(&msg);
        zmq_msg_recv(&msg, subscriber, 0);
        
        printf("filter=\"%s\" msg: %s\n", filter, zmq_msg_data(&msg));
        
        zmq_msg_close(&msg);
    }
    
    zmq_close(subscriber);
    zmq_ctx_destroy(context);
    
    return 0;
}

/**
g++ div-con-ventilator.cpp -lzmq -g -O0 -o objs/div-con-ventilator
*/
#include <zmq.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* ventilator = zmq_socket(context, ZMQ_PUSH);
    zmq_bind(ventilator, "tcp://*:1990");
    
    srand(0);
    int task_num = (argc > 1)? atoi(argv[1]) : 100;
    printf("ventilator will dispatch %d task to worker.\n", task_num);
    
    // we must wait for worker to connect to the ventilator,
    // if there is 10/100 workers connected, we will dispatch to the 10 workers,
    // the left 90 workers will get workers when they connect to ventilator.
    printf("when all worker is online, press any key to dispatch tasks...");
    getchar();
    
    while(true){
        for(int i = 0; i < task_num; i++){
            printf("start to dispatch %d task\n", i + 1);
            zmq_msg_t msg;
            zmq_msg_init_size(&msg, 4);
            int time = rand() % 10;
            memcpy(zmq_msg_data(&msg), &time, 4);
            zmq_msg_send(&msg, ventilator, 0);
            printf("dispatch %d task completed\n", i + 1);
        }
        
        sleep(10);
        // if there is new worker, we can dispatch task to it.
        printf("dispatch the task again!\n");
    }
    
    zmq_close(ventilator);
    zmq_ctx_destroy(context);
    return 0;
}

/**
g++ div-con-worker.cpp -lzmq -g -O0 -o objs/div-con-worker
*/
#include <zmq.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    
    void* worker_receiver = zmq_socket(context, ZMQ_PULL);
    zmq_connect(worker_receiver, "tcp://localhost:1990");
    
    void* sink_sender = zmq_socket(context, ZMQ_PUSH);
    zmq_connect(sink_sender, "tcp://localhost:1991");
    
    while(true){
        int time;
        
        // pull work
        if(true){
            zmq_msg_t msg;
            zmq_msg_init(&msg);
            zmq_msg_recv(&msg, worker_receiver, 0);
            memcpy(&time, zmq_msg_data(&msg), 4);
            zmq_msg_close(&msg);
            
            printf("get a worker, time=%d\n", time);
        }
        
        // do work
        sleep(time);
        printf("work completed.\n");
        
        // report work
        if(true){
            char buf[64];
            snprintf(buf, sizeof(buf), "time=%d", time);
            
            zmq_msg_t msg;
            zmq_msg_init_size(&msg, strlen(buf) + 1);
            memcpy(zmq_msg_data(&msg), buf, strlen(buf) + 1);
            zmq_msg_send(&msg, sink_sender, 0);
            zmq_msg_close(&msg);
            
            printf("work report to sink completed, %s\n", buf);
        }
    }
    
    zmq_close(sink_sender);
    zmq_close(worker_receiver);
    zmq_ctx_destroy(context);
    return 0;
}

/**
g++ div-con-sink.cpp -lzmq -g -O0 -o objs/div-con-sink
*/
#include <zmq.h>
#include <stdlib.h>

int main(int argc, char** argv){
    void* context = zmq_ctx_new();
    void* sink = zmq_socket(context, ZMQ_PULL);
    zmq_bind(sink, "tcp://*:1991");
    
    while(true){
        zmq_msg_t msg;
        zmq_msg_init(&msg);
        zmq_msg_recv(&msg, sink, 0);
        
        printf("sink get a work report: %s\n", zmq_msg_data(&msg));
    }
    
    zmq_close(sink);
    zmq_ctx_destroy(context);
    return 0;
}