// 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;
}
static void *
zap_handler (void *zap)
{
char *version = s_recv (zap);
char *sequence = s_recv (zap);
char *domain = s_recv (zap);
char *address = s_recv (zap);
char *mechanism = s_recv (zap);
char *client_key = s_recv (zap);
assert (streq (version, "1.0"));
assert (streq (mechanism, "CURVE"));
s_sendmore (zap, version);
s_sendmore (zap, sequence);
s_sendmore (zap, "200");
s_sendmore (zap, "OK");
s_sendmore (zap, "anonymous");
s_send (zap, "");
free (version);
free (sequence);
free (domain);
free (address);
free (mechanism);
free (client_key);
int rc = zmq_close (zap);
assert (rc == 0);
return NULL;
}
// We will do this all in one thread to emphasize the sequence
// of events...
int main () {
zmq::context_t context(1);
zmq::socket_t client (context, ZMQ_XREP);
client.bind("ipc://routing.ipc");
zmq::socket_t worker (context, ZMQ_REP);
worker.setsockopt(ZMQ_IDENTITY, "A", 1);
worker.connect("ipc://routing.ipc");
// Wait for sockets to stabilize
sleep (1);
// Send papa address, address stack, empty part, and request
s_sendmore (client, "A");
s_sendmore (client, "address 3");
s_sendmore (client, "address 2");
s_sendmore (client, "address 1");
s_sendmore (client, "");
s_send (client, "This is the workload");
// Worker should get just the workload
s_dump (worker);
// We don't play with envelopes in the worker
s_send (worker, "This is the reply");
// Now dump what we got off the XREP socket...
s_dump (client);
return 0;
}
// We will do this all in one thread to emphasize the sequence
// of events...
int main () {
void *context = zmq_init (1);
void *client = zmq_socket (context, ZMQ_XREP);
zmq_bind (client, "ipc://routing");
void *worker = zmq_socket (context, ZMQ_REP);
zmq_setsockopt (worker, ZMQ_IDENTITY, "A", 1);
zmq_connect (worker, "ipc://routing");
// Wait for sockets to stabilize
sleep (1);
// Send papa address, address stack, empty part, and request
s_sendmore (client, "A");
s_sendmore (client, "address 3");
s_sendmore (client, "address 2");
s_sendmore (client, "address 1");
s_sendmore (client, "");
s_send (client, "This is the workload");
// Worker should get just the workload
s_dump (worker);
// We don't play with envelopes in the worker
s_send (worker, "This is the reply");
// Now dump what we got off the XREP socket...
s_dump (client);
zmq_term (context);
return 0;
}
//recRequest by one of the Satellites, reply with number of stored msgs and the oldest stored msg
void ReefServer::recRequest(std::string aka){
//find satellite by alias in the map
auto search = satMsgControlMap.find(aka);
if (search != satMsgControlMap.end()) { //if sat has been found
//get the Controlnumbers for this satellite
satelliteMsgControl& msgControl = search->second;
int msgCount = msgControl.control[1]; //number of stored Messages for this Satellite
if (!msgCount){
s_send(rep, std::to_string(msgCount)); //send the number of messages to the satellite
}
else{
s_sendmore(rep, std::to_string(msgCount)); //send the number of messages to the satellite
int msgPosition = msgControl.control[0]; //find position of Message Queue in the vector of all Queues
std::pair<std::string, std::string> msg = satelliteMsgs[msgPosition][0];
s_sendmore(rep, msg.first); //send the Message to the satellite
s_send(rep, msg.second);
satelliteMsgs[msgPosition].erase(satelliteMsgs[msgPosition].begin()); //erase the Message from the Queue
msgControl.control[1]--; //lower the count of stored Messages by 1
CUR_MESSAGES--;
}
}
else{
s_send(rep, "-1");
}
}
// 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);
}
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;
}
// 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)
{
void *context = zmq_ctx_new ();
void *worker = zmq_socket (context, ZMQ_DEALER);
s_set_id (worker); // Set a printable identity
zmq_connect (worker, "tcp://localhost:5671");
int total = 0;
while (1) {
// Tell the broker we're ready for work
s_sendmore (worker, "");
s_send (worker, "Hi Boss");
// Get workload from broker, until finished
// free (s_recv (worker)); // Envelope delimiter
// char *workload = s_recv (worker);
// int finished = (strcmp (workload, "Fired!") == 0);
// free (workload);
// if (finished) {
// printf ("Completed: %d tasks\n", total);
// break;
// }
total++;
// Do some random work
s_sleep (randof (500) + 1);
}
zmq_close (worker);
zmq_ctx_destroy (context);
return 0;
}
int main() {
// Prepare our context and publisher
zmq::context_t context(1);
zmq::socket_t publisher(context, ZMQ_REP);
publisher.bind("tcp://*:5556");
// Create the fake walk
std::string walk[800];
int i;
for (i = 0; i < 800; i++) {
walk[i] = std::to_string(i) + " " + std::to_string(i);
}
i = 0;
while (true) {
// Just repeat the walk
if (i >= 800) i = 0;
// Send envelope
s_sendmore(publisher, "pos");
s_send(publisher, walk[i]);
// Synchronize with client
usleep(10);
i++;
}
return 0;
}
bool ServerZMQ::_onUpdate()
{
if (s_interrupted)
{
return false;
}
int result;
const TString& subscriberId = this->getSubscribeId();
result = s_sendmore(m_socket, subscriberId.c_str());
if (result == -1)
{
DMSG_LOGGER("Error occurred during send subscribe id");
return false;
}
const TString& message = getMessageString();
//TString msg = message;
//std::replace(msg.begin(), msg.end(), '{', ')');
//DMSG_LOGGER(message.c_str());
result = s_send(m_socket, message.c_str());
if (result == -1)
{
zmqlog("Error occurred during send message ");
DMSG_LOGGER("Error sending %s ", message.c_str());
return false;
}
//sleep for 1 to 2 seconds
int sleeptime = (rand() % 1000) + 1000;
s_sleep(sleeptime);
return true;
}
int main () {
// Prepare our context and publisher
void *context = zmq_init (1);
void *publisher = zmq_socket (context, ZMQ_PUB);
zmq_bind (publisher, "tcp://*:5563");
while (1) {
// Write two messages, each with an envelope and content
s_sendmore (publisher, "A");
s_send (publisher, "We don't want to see this");
s_sendmore (publisher, "B");
s_send (publisher, "We would like to see this");
sleep (1);
}
zmq_term (context);
return 0;
}
void emit(char *jsonstring)
{
if (config.emit_verbose)
printf("%s\n", jsonstring);
s_sendmore(config.zpublisher, config.ztopic);
s_send(config.zpublisher, jsonstring);
}
void ReefServer::connectRequest(std::string aka, std::string ownIp, std::string reefIp){
std::string ip_str = "tcp://" + reefIp;
req.connect(ip_str.c_str()); //connect to 1 Server-Coral of Reef
s_sendmore(req, "0");
s_sendmore(req, aka.c_str()); //send wished alias
s_send(req, ownIp.c_str()); //send adress of own publisher
//receive the reply
zmq::message_t reply;
req.recv(&reply);
//get the json-string with adress-list of Reef-Corals from the reply
std::string json = std::string(static_cast<char*>(reply.data()), reply.size());
//parse the json to a JsonObject and save it as the new adr_list
adr_list = *CJsonParser::Execute((jstring)json);
}
static void
zap_handler (void *ctx)
{
// Create and bind ZAP socket
void *zap = zmq_socket (ctx, ZMQ_REP);
assert (zap);
int rc = zmq_bind (zap, "inproc://zeromq.zap.01");
assert (rc == 0);
// Process ZAP requests forever
while (true) {
char *version = s_recv (zap);
if (!version)
break; // Terminating
char *sequence = s_recv (zap);
char *domain = s_recv (zap);
char *address = s_recv (zap);
char *identity = s_recv (zap);
char *mechanism = s_recv (zap);
assert (streq (version, "1.0"));
assert (streq (mechanism, "NULL"));
// TODO: null_mechanism.cpp issues ZAP requests for connections other
// than the expected one. In these cases identity is not set, and the
// test fails. We'd expect one ZAP request per real client connection.
// assert (streq (identity, "IDENT"));
s_sendmore (zap, version);
s_sendmore (zap, sequence);
s_sendmore (zap, "200");
s_sendmore (zap, "OK");
s_sendmore (zap, "anonymous");
s_send (zap, "");
free (version);
free (sequence);
free (domain);
free (address);
free (identity);
free (mechanism);
}
rc = zmq_close (zap);
assert (rc == 0);
}
void str_send_to (void *s_, const char *content_, const char *address_)
{
// Send the address part
int rc = s_sendmore (s_, address_);
assert (rc > 0);
rc = s_send (s_, content_);
assert (rc > 0);
}
// .split main task
// While this example runs in a single process, that is just to make
// it easier to start and stop the example. Each thread has its own
// context and conceptually acts as a separate process.
int main() {
zmq::context_t context(1);
zmq::socket_t broker(context, ZMQ_ROUTER);
broker.bind("tcp://*:5671");
srandom((unsigned)time(NULL));
const int NBR_WORKERS = 10;
pthread_t workers[NBR_WORKERS];
for (int worker_nbr = 0; worker_nbr < NBR_WORKERS; ++worker_nbr) {
pthread_create(workers + worker_nbr, NULL, worker_task, (void *)(intptr_t)worker_nbr);
}
// Run for five seconds and then tell workers to end
int64_t end_time = s_clock() + 5000;
int workers_fired = 0;
while (1) {
// Next message gives us least recently used worker
std::string identity = s_recv(broker);
{
s_recv(broker); // Envelope delimiter
s_recv(broker); // Response from worker
}
s_sendmore(broker, identity);
s_sendmore(broker, "");
// Encourage workers until it's time to fire them
if (s_clock() < end_time)
s_send(broker, "Work harder");
else {
s_send(broker, "Fired!");
if (++workers_fired == NBR_WORKERS)
break;
}
}
for (int worker_nbr = 0; worker_nbr < NBR_WORKERS; ++worker_nbr) {
pthread_join(workers[worker_nbr], NULL);
}
return 0;
}
static void
zap_handler (void *ctx)
{
// Create and bind ZAP socket
void *zap = zmq_socket (ctx, ZMQ_REP);
assert (zap);
int rc = zmq_bind (zap, "inproc://zeromq.zap.01");
assert (rc == 0);
// Process ZAP requests forever
while (true) {
char *version = s_recv (zap);
if (!version)
break; // Terminating
char *sequence = s_recv (zap);
char *domain = s_recv (zap);
char *address = s_recv (zap);
char *identity = s_recv (zap);
char *mechanism = s_recv (zap);
char *username = s_recv (zap);
char *password = s_recv (zap);
assert (streq (version, "1.0"));
assert (streq (mechanism, "PLAIN"));
assert (streq (identity, "IDENT"));
s_sendmore (zap, version);
s_sendmore (zap, sequence);
if (streq (username, "admin")
&& streq (password, "password")) {
s_sendmore (zap, "200");
s_sendmore (zap, "OK");
s_sendmore (zap, "anonymous");
s_send (zap, "");
}
else {
s_sendmore (zap, "400");
s_sendmore (zap, "Invalid username or password");
s_sendmore (zap, "");
s_send (zap, "");
}
free (version);
free (sequence);
free (domain);
free (address);
free (identity);
free (mechanism);
free (username);
free (password);
}
rc = zmq_close (zap);
assert (rc == 0);
}
int main(void) {
void *context = zmq_init(1);
void *client = zmq_socket(context, ZMQ_ROUTER);
zmq_bind(client, "ipc://routing.ipc");
srandom((unsigned) time(NULL));
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
pthread_t worker;
pthread_create(&worker, NULL, worker_task, NULL);
}
int task_nbr;
for (task_nbr = 0; task_nbr < NBR_WORKERS * 10; task_nbr++) {
// 最近最少使用的worker就在消息队列中
char *address = s_recv(client);
char *empty = s_recv(client);
free(empty);
char *ready = s_recv(client);
free(ready);
s_sendmore(client, address);
s_sendmore(client, "");
s_send(client, "This is the workload");
free(address);
}
// 通知所有REQ套接字结束工作
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
char *address = s_recv(client);
char *empty = s_recv(client);
free(empty);
char *ready = s_recv(client);
free(ready);
s_sendmore(client, address);
s_sendmore(client, "");
s_send(client, "END");
free(address);
}
zmq_close(client);
zmq_term(context);
return 0;
}
int main () {
void *context = zmq_init (1);
void *client = zmq_socket (context, ZMQ_XREP);
zmq_bind (client, "ipc://routing.ipc");
srandom ((unsigned) time (NULL));
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
pthread_t worker;
pthread_create (&worker, NULL, worker_thread, context);
}
int task_nbr;
for (task_nbr = 0; task_nbr < NBR_WORKERS * 10; task_nbr++) {
// LRU worker is next waiting in queue
char *address = s_recv (client);
char *empty = s_recv (client);
free (empty);
char *ready = s_recv (client);
free (ready);
s_sendmore (client, address);
s_sendmore (client, "");
s_send (client, "This is the workload");
free (address);
}
// Now ask mamas to shut down and report their results
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
char *address = s_recv (client);
char *empty = s_recv (client);
free (empty);
char *ready = s_recv (client);
free (ready);
s_sendmore (client, address);
s_sendmore (client, "");
s_send (client, "END");
free (address);
}
sleep (1); // Give 0MQ/2.0.x time to flush output
zmq_term (context);
return 0;
}
int main () {
zmq::context_t context(1);
zmq::socket_t client (context, ZMQ_XREP);
client.bind("ipc://routing.ipc");
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
pthread_t worker;
pthread_create (&worker, NULL, worker_thread, &context);
}
int task_nbr;
for (task_nbr = 0; task_nbr < NBR_WORKERS * 10; task_nbr++) {
// LRU worker is next waiting in queue
std::string address = s_recv (client);
{
// receiving and discarding'empty' message
s_recv (client);
// receiving and discarding 'ready' message
s_recv (client);
}
s_sendmore (client, address);
s_sendmore (client, "");
s_send (client, "This is the workload");
}
// Now ask mamas to shut down and report their results
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++) {
std::string address = s_recv (client);
{
// receiving and discarding'empty' message
s_recv (client);
// receiving and discarding 'ready' message
s_recv (client);
}
s_sendmore (client, address);
s_sendmore (client, "");
s_send (client, "END");
}
sleep (1); // Give 0MQ/2.0.x time to flush output
return 0;
}
int main (void)
{
void *context = zmq_ctx_new ();
void *responder = zmq_socket (context, ZMQ_ROUTER);
int rc = zmq_bind (responder, "tcp://*:5555");
assert (rc == 0);
while (1)
{
char identity[10]={0};
//recv client`s request msg
//the 1st received frame is identity frame
char *frame1=s_recv(responder);
printf("[recv] frame1 = %s\n",frame1);
memcpy(identity, frame1, strlen(frame1)+1); //save the identity to char array identity
free(frame1);
//the 2nd frame received is empty delimiter frame
char *frame2= s_recv(responder);
printf("[recv] frame2 = %s\n", frame2);
assert(frame2[0] == 0);
free(frame2);
//the 3rd frame received is data frame
char *frame3=s_recv(responder);
printf("[recv] frame3 = %s\n", frame3);
free(frame3);
sleep (1); //Do some work
//send respond msg to client
printf("[send] frame1 = %s\n", identity);
printf("[send] frame2 = %s\n", "");
printf("[send] frame3 = %s\n\n", "World");
s_sendmore(responder,identity); //send identity frame
s_sendmore(responder,""); //send empty delimiter frame
s_send (responder, "World"); //send data frame
memset(identity, 0, sizeof(identity)); //clear up identity array
}
zmq_close(responder);
zmq_ctx_destroy(context);
return 0;
}
int main (void)
{
// Prepare our context and publisher
void *context = zmq_ctx_new ();
void *publisher = zmq_socket (context, ZMQ_PUB);
zmq_bind (publisher, "tcp://*:5563");
while (1) {
// Write two messages, each with an envelope and content
s_sendmore (publisher, "A");
s_send (publisher, "We don't want to see this");
s_sendmore (publisher, "B");
s_send (publisher, "We would like to see this");
sleep (1);
}
// We never get here but clean up anyhow
zmq_close (publisher);
zmq_ctx_destroy (context);
return 0;
}
// We will do this all in one thread to emphasize the sequence
// of events...
int main (void)
{
void *context = zmq_init (1);
void *client = zmq_socket (context, ZMQ_ROUTER);
zmq_bind (client, "ipc://routing.ipc");
void *worker = zmq_socket (context, ZMQ_REP);
zmq_setsockopt (worker, ZMQ_IDENTITY, "A", 1);
zmq_connect (worker, "ipc://routing.ipc");
// Wait for the worker to connect so that when we send a message
// with routing envelope, it will actually match the worker...
sleep (1);
// Send papa address, address stack, empty part, and request
s_sendmore (client, "A");
s_sendmore (client, "address 3");
s_sendmore (client, "address 2");
s_sendmore (client, "address 1");
s_sendmore (client, "");
s_send (client, "This is the workload");
// Worker should get just the workload
printf("begine dump worker\n");
s_dump (worker);
// We don't play with envelopes in the worker
s_send (worker, "This is the reply");
// Now dump what we got off the ROUTER socket...
printf("begine dump client\n");
s_dump (client);
zmq_close (client);
zmq_close (worker);
zmq_term (context);
return 0;
}
// .split worker task
// While this example runs in a single process, that is just to make
// it easier to start and stop the example. Each thread has its own
// context and conceptually acts as a separate process.
// This is the worker task, using a REQ socket to do load-balancing.
// Because s_send and s_recv can't handle 0MQ binary identities, we
// set a printable text identity to allow routing.
static void *worker_task(void *args)
{
void *context = zmq_ctx_new();
void *worker = zmq_socket(context, ZMQ_REQ);
#if (defined (WIN32))
s_set_id(worker, (intptr_t)args);
zmq_connect(worker, "tcp://localhost:5673"); // backend
#else
s_set_id(worker);
zmq_connect(worker, "ipc://backend.ipc");
#endif
// 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 there 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 from %s\n", request, identity);
free(request);
s_sendmore(worker, identity);
s_sendmore(worker, "");
s_send(worker, "OK");
free(identity);
}
zmq_close(worker);
zmq_ctx_destroy(context);
return NULL;
}
static void zap_handler (void *handler)
{
// Process ZAP requests forever
while (true) {
char *version = s_recv (handler);
if (!version)
break; // Terminating
char *sequence = s_recv (handler);
char *domain = s_recv (handler);
char *address = s_recv (handler);
char *identity = s_recv (handler);
char *mechanism = s_recv (handler);
uint8_t client_key [32];
int size = zmq_recv (handler, client_key, 32, 0);
assert (size == 32);
char client_key_text [40];
zmq_z85_encode (client_key_text, client_key, 32);
assert (streq (version, "1.0"));
assert (streq (mechanism, "CURVE"));
assert (streq (identity, "IDENT"));
s_sendmore (handler, version);
s_sendmore (handler, sequence);
if (streq (client_key_text, client_public)) {
s_sendmore (handler, "200");
s_sendmore (handler, "OK");
s_sendmore (handler, "anonymous");
s_send (handler, "");
}
else {
s_sendmore (handler, "400");
s_sendmore (handler, "Invalid client public key");
s_sendmore (handler, "");
s_send (handler, "");
}
free (version);
free (sequence);
free (domain);
free (address);
free (identity);
free (mechanism);
}
zmq_close (handler);
}
/*
* ZAP request handling loop.
*/
static void zap_handler(void *handler)
{
for (;;) {
char *version, *sequence, *domain, *address, *identity, *mechanism;
/* Receive request. */
if(!(version = s_tryrecv(handler)))
break;
sequence = s_recvmore(handler);
domain = s_recvmore(handler);
address = s_recvmore(handler);
identity = s_recvmore(handler);
mechanism = s_recvmore(handler);
assert(!has_more(handler));
assert(!strcmp(version, "1.0"));
assert(!strcmp(mechanism, "NULL"));
printf("ZAP REQUEST %s %s %s %s %s %s\n", version, sequence, domain,
address, identity, mechanism);
/* Send reply. */
s_sendmore(handler, version);
s_sendmore(handler, sequence);
if(!strcmp(domain, "test")) {
s_sendmore(handler, "200");
s_sendmore(handler, "OK");
s_sendmore(handler, "anonymous");
printf("ZAP REPLY 1.0 %s 200 OK anonymous\n", sequence);
} else {
s_sendmore(handler, "500");
s_sendmore(handler, "Denied");
s_sendmore(handler, "");
printf("ZAP REPLY 1.0 %s 200 Denied\n", sequence);
}
s_send(handler, "");
/* Cleanup. */
free(version);
free(sequence);
free(domain);
free(address);
free(identity);
free(mechanism);
}
zmq_close(handler);
}
int main (void)
{
void *context = zmq_init (1);
void *client = zmq_socket (context, ZMQ_ROUTER);
zmq_bind (client, "ipc://routing.ipc");
pthread_t worker;
pthread_create (&worker, NULL, worker_task_a, NULL);
pthread_create (&worker, NULL, worker_task_b, NULL);
// Wait for threads to connect, since otherwise the messages
// we send won't be routable.
sleep (1);
// Send 10 tasks scattered to A twice as often as B
int task_nbr;
srandom ((unsigned) time (NULL));
for (task_nbr = 0; task_nbr < 10; task_nbr++) {
// Send two message parts, first the address...
if (randof (3) > 0)
s_sendmore (client, "A");
else
s_sendmore (client, "B");
// And then the workload
s_send (client, "This is the workload");
}
s_sendmore (client, "A");
s_send (client, "END");
s_sendmore (client, "B");
s_send (client, "END");
zmq_close (client);
zmq_term (context);
return 0;
}
static void
zap_handler (void *handler)
{
uint8_t metadata [] = {
5, 'H', 'e', 'l', 'l', 'o',
0, 0, 0, 5, 'W', 'o', 'r', 'l', 'd'
};
// Process ZAP requests forever
while (true) {
char *version = s_recv (handler);
if (!version)
break; // Terminating
char *sequence = s_recv (handler);
char *domain = s_recv (handler);
char *address = s_recv (handler);
char *routing_id = s_recv (handler);
char *mechanism = s_recv (handler);
assert (streq (version, "1.0"));
assert (streq (mechanism, "NULL"));
s_sendmore (handler, version);
s_sendmore (handler, sequence);
if (streq (domain, "DOMAIN")) {
s_sendmore (handler, "200");
s_sendmore (handler, "OK");
s_sendmore (handler, "anonymous");
zmq_send (handler, metadata, sizeof (metadata), 0);
}
else {
s_sendmore (handler, "400");
s_sendmore (handler, "BAD DOMAIN");
s_sendmore (handler, "");
s_send (handler, "");
}
free (version);
free (sequence);
free (domain);
free (address);
free (routing_id);
free (mechanism);
}
close_zero_linger (handler);
}
int main22 () {
zmq::context_t context(1);
zmq::socket_t client (context, ZMQ_ROUTER);
client.bind("tcp://*:5555");
pthread_t worker;
pthread_create (&worker, NULL, worker_a, &context);
pthread_create (&worker, NULL, worker_b, &context);
// Wait for threads to stabilize
s_sleep (1000);
// Send 10 tasks scattered to A twice as often as B
int task_nbr;
srand ((unsigned) time (NULL));
for (task_nbr = 0; task_nbr < 100; task_nbr++) {
// Send two message parts, first the address...
if (within (3) > 0)
s_sendmore (client, "A");
else
s_sendmore (client, "B");
// And then the workload
s_send (client, "This is the workload");
}
s_sendmore (client, "A");
s_send (client, "END");
s_sendmore (client, "B");
s_send (client, "END");
s_sleep (1000); // Give 0MQ/2.0.x time to flush output
return 0;
}
