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()
{
// 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)
{
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(){
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;
}
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;
}
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);
}
static void *
worker_task(void *args) {
void *context = zmq_init(1);
void *worker = zmq_socket(context, ZMQ_REQ);
// s_set_id()函数会根据套接字生成一个可打印的字符串，
// 并以此作为该套接字的标识。
s_set_id(worker);
zmq_connect(worker, "ipc://routing.ipc");
int total = 0;
while (1) {
// 告诉ROUTER我已经准备好了
s_send(worker, "ready");
// 从ROUTER中获取工作，直到收到结束的信息
char *workload = s_recv(worker);
int finished = (strcmp(workload, "END") == 0);
free(workload);
if (finished) {
printf("Processed: %d tasks\n", total);
break;
}
total++;
// 随机等待一段时间
s_sleep(randof(1000) + 1);
}
zmq_close(worker);
zmq_term(context);
return NULL;
}
zmsg_t *
mdwrk_recv (mdwrk_t *self, zmsg_t *reply)
{
// Format and send the reply if we were provided one
assert (reply || !self->expect_reply);
if (reply) {
zmsg_t *msg = zmsg_dup (reply);
zmsg_push (msg, MDPS_REPLY);
zmsg_push (msg, MDPS_HEADER);
zmsg_send (&msg, self->worker);
}
self->expect_reply = 1;
while (1) {
zmq_pollitem_t items [] = { { self->worker, 0, ZMQ_POLLIN, 0 } };
zmq_poll (items, 1, HEARTBEAT_INTERVAL * 1000);
if (items [0].revents & ZMQ_POLLIN) {
zmsg_t *msg = zmsg_recv (self->worker);
self->liveness = HEARTBEAT_LIVENESS;
// Don't try to handle errors, just assert noisily
assert (zmsg_parts (msg) >= 3);
char *header = zmsg_pop (msg);
assert (strcmp (header, MDPS_HEADER) == 0);
free (header);
char *command = zmsg_pop (msg);
if (strcmp (command, MDPS_REQUEST) == 0)
return msg; // We have a request to process
else
if (strcmp (command, MDPS_HEARTBEAT) == 0)
; // Do nothing for heartbeats
else
if (strcmp (command, MDPS_DISCONNECT) == 0)
break; // Return empty handed
else {
printf ("E: invalid input message (%d)\n", (int) command [1]);
zmsg_dump (msg);
}
free (command);
}
else
if (--self->liveness == 0) {
s_sleep (RECONNECT_INTERVAL);
s_connect_to_broker (self);
}
// Send HEARTBEAT if it's time
if (s_clock () > self->heartbeat_at) {
self->heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
s_send (self->worker, "HEARTBEAT");
}
}
// We exit if we've been disconnected
return NULL;
}
void
flcliapi_connect (flcliapi_t *self, char *endpoint)
{
assert (self);
assert (endpoint);
zmsg_t *msg = zmsg_new (endpoint);
zmsg_push (msg, "CONNECT");
zmsg_send (&msg, self->control);
s_sleep (100); // Allow connection to come up
}
int main (int argc, char *argv[])
{
zmq::context_t context(1);
// Socket to receive messages on
zmq::socket_t receiver(context, ZMQ_PULL);
receiver.connect("tcp://localhost:5557");
// Socket to send messages to
zmq::socket_t sender(context, ZMQ_PUSH);
sender.connect("tcp://localhost:5558");
// Socket for control input
zmq::socket_t controller (context, ZMQ_SUB);
controller.connect("tcp://localhost:5559");
controller.setsockopt(ZMQ_SUBSCRIBE, "", 0);
// Process messages from receiver and controller
zmq::pollitem_t items [] = {
{ receiver, 0, ZMQ_POLLIN, 0 },
{ controller, 0, ZMQ_POLLIN, 0 }
};
// Process messages from both sockets
while (1) {
zmq::message_t message;
zmq::poll (&items [0], 2, -1);
if (items [0].revents & ZMQ_POLLIN) {
receiver.recv(&message);
// Process task
int workload; // Workload in msecs
std::istringstream iss(static_cast<char*>(message.data()));
iss >> workload;
// Do the work
s_sleep(workload);
// Send results to sink
message.rebuild();
sender.send(message);
// Simple progress indicator for the viewer
std::cout << "." << std::flush;
}
// Any waiting controller command acts as 'KILL'
if (items [1].revents & ZMQ_POLLIN)
{
std::cout << std::endl;
break; // Exit loop
}
}
int main (void)
{
void *context = zmq_ctx_new ();
// 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");
// Socket for control input
void *controller = zmq_socket (context, ZMQ_SUB);
zmq_connect (controller, "tcp://localhost:5559");
zmq_setsockopt (controller, ZMQ_SUBSCRIBE, "", 0);
// Process messages from receiver and controller
zmq_pollitem_t items [] = {
{ receiver, 0, ZMQ_POLLIN, 0 },
{ controller, 0, ZMQ_POLLIN, 0 }
};
// Process messages from both sockets
while (true) {
zmq_msg_t message;
zmq_poll (items, 2, -1);
if (items [0].revents & ZMQ_POLLIN) {
zmq_msg_init (&message);
zmq_msg_recv (&message, receiver, 0);
// Do the work
s_sleep (atoi ((char *) zmq_msg_data (&message)));
// Send results to sink
zmq_msg_init (&message);
zmq_msg_send (&message, sender, 0);
// Simple progress indicator for the viewer
printf (".");
fflush (stdout);
zmq_msg_close (&message);
}
// Any waiting controller command acts as 'KILL'
if (items [1].revents & ZMQ_POLLIN)
break; // Exit loop
}
// Finished
zmq_close (receiver);
zmq_close (sender);
zmq_close (controller);
zmq_ctx_destroy (context);
return 0;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdcli_t *session = mdcli_new ("tcp://localhost:5555", verbose);
// 1. Send 'echo' request to Titanic
zmsg_t *request = zmsg_new ("Hello world");
zmsg_push (request, "echo");
zmsg_t *reply = s_service_call (
session, "titanic.request", &request);
char *uuid = NULL;
if (reply) {
uuid = zmsg_pop (reply);
zmsg_destroy (&reply);
printf ("I: request UUID: %s\n", uuid);
}
// 2. Wait until we get a reply
while (!s_interrupted) {
s_sleep (100);
request = zmsg_new (uuid);
zmsg_t *reply = s_service_call (
session, "titanic.reply", &request);
if (reply) {
printf ("Reply: %s\n", zmsg_body (reply));
zmsg_destroy (&reply);
// 3. Close request
request = zmsg_new (uuid);
reply = s_service_call (session, "titanic.close", &request);
zmsg_destroy (&reply);
break;
}
else {
printf ("I: no reply yet, trying again...\n");
s_sleep (5000); // Try again in 5 seconds
}
}
mdcli_destroy (&session);
return 0;
}
int main (void)
{
// prepare our context and sockets
void *context = zmq_init (1);
// Connect to task ventilator
void *receiver = zmq_socket (context, ZMQ_PULL);
zmq_connect (receiver, "tcp://localhost:5557");
// Connect to weather server
void *subscriber = zmq_socket (context, ZMQ_SUB);
zmq_connect (subscriber, "tcp://localhost:5556");
zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "10001 ", 6);
// Process messages from both sockets
// We priortize traffic from the task ventilator
while (1)
{
// Process any waitting tasks
int rc;
for (rc = 0; rc == 0; )
{
zmq_msg_t task;
zmq_msg_init (&task);
if ((rc = zmq_recv (receiver, &task, ZMQ_NOBLOCK)) == 0)
{
// process task
printf ("Task received\n");
}
zmq_msg_close (&task);
}
// Process any waitting weather updates
for (rc = 0; rc == 0;)
{
zmq_msg_t update;
zmq_msg_init (&update);
if ((rc = zmq_recv (subscriber, &update, ZMQ_NOBLOCK)) == 0)
{
// process weather update
printf ("Weather update received\n");
}
zmq_msg_close (&update);
}
// No activity, so sleep for 1 msec
s_sleep (1);
}
// We never get here but clean up anyhow
zmq_close (receiver);
zmq_close (subscriber);
zmq_term (context);
return 0;
}
int main(void)
{
pthread_t frontend,backend,switchend;
void *context = zmq_ctx_new();
routine_arg_t arg;
arg.context = context;
arg.switch_port = 9999;
arg.direct_port = 10000;
arg.device_port = 9000;
s_sleep(100);
pthread_create(&frontend, NULL, direct_routine, &arg);
s_sleep(1000);
pthread_create(&switchend, NULL, switch_routine, &arg);
s_sleep(1000);
pthread_create(&backend, NULL, device_routine, &arg);
s_sleep(1000000);
//我喜欢简单粗暴.. 所有没有关闭线程就退出了:)
return 0;
}
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;
}
int main (void)
{
// Prepare our context and sockets
void *context = zmq_ctx_new ();
// Connect to task ventilator
void *receiver = zmq_socket (context, ZMQ_PULL);
zmq_connect (receiver, "tcp://localhost:5557");
// Connect to weather server
void *subscriber = zmq_socket (context, ZMQ_SUB);
zmq_connect (subscriber, "tcp://localhost:5556");
zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, "10001 ", 6);
// Process messages from both sockets
// We prioritize traffic from the task ventilator
while (1) {
// Process any waiting tasks
int rc;
for (rc = 0; !rc; ) {
zmq_msg_t task;
zmq_msg_init (&task);
if ((rc = zmq_msg_recv (&task, receiver, ZMQ_DONTWAIT)) != -1) {
// process task
}
zmq_msg_close (&task);
}
// Process any waiting weather updates
for (rc = 0; !rc; ) {
zmq_msg_t update;
zmq_msg_init (&update);
if ((rc = zmq_msg_recv (&update, subscriber, ZMQ_DONTWAIT)) != -1) {
// process weather update
}
zmq_msg_close (&update);
}
// No activity, so sleep for 1 msec
s_sleep (1);
}
// We never get here but clean up anyhow
zmq_close (receiver);
zmq_close (subscriber);
zmq_ctx_destroy (context);
return 0;
}
virtual void workFunc()
{
// Socket to talk to dispatcher
void *receiver = zmq_socket(context_, ZMQ_REP);
zmq_connect(receiver, "inproc://workers");
while (1)
{
char *string = s_recv(receiver);
printf("#%d Received request: [%s]\n", no_, string);
free(string);
s_sleep(1);
s_send(receiver, "World");
}
zmq_close(receiver);
}
int main21 () {
zmq::context_t context(1);
zmq::socket_t client (context, ZMQ_ROUTER);
client.bind("tcp://*:5555");
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 * 4; 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");
}
s_sleep (1000); // Give 0MQ/2.0.x time to flush output
return 0;
}
int main5 (int argc, char *argv[])
{
zmq::context_t context (1);
// Socket to send messages on
zmq::socket_t sender(context, ZMQ_PUSH);
sender.bind("tcp://*:5557");
std::cout << "Press Enter when the workers are ready: " << std::endl;
getchar ();
std::cout << "Sending tasks to workers...\n" << std::endl;
// The first message is "0" and signals start of batch
zmq::socket_t sink(context, ZMQ_PUSH);
sink.connect("tcp://localhost:5558");
zmq::message_t message(2);
memcpy(message.data(), "0", 1);
sink.send(message);
// Initialize random number generator
srand ((unsigned) time (NULL));
// Send 100 tasks
int task_nbr;
int total_msec = 0; // Total expected cost in msecs
for (task_nbr = 0; task_nbr < 100; task_nbr++) {
int workload;
// Random workload from 1 to 100msecs
workload = within (100) + 1;
total_msec += workload;
message.rebuild(10);
sprintf ((char *) message.data(), "%d", workload);
sender.send(message);
}
std::cout << "Total expected cost: " << total_msec << " msec" << std::endl;
s_sleep (1); // Give 0MQ time to deliver
return 0;
}
int32_t Worker::RequestHandler::handleRequest(const SplitInfo &request,
base::ProducerConsumerQueue<base::Block<SplitInfo> >* queue) {
LOG(INFO) << "fetching split " << request.filename <<
" start: " << request.start <<
" end: " << request.end <<
" schema: " << request.schema <<
" objectType: " << request.objectType;
#if 0
const uint64_t sleepTimeMs = 1000;
const uint64_t kNumProgressUpdates = 1;
uint64_t bytesPerUpdate = (request.end - request.start) / kNumProgressUpdates;
/**
* Send status updates
*/
for(int i = 0; i < kNumProgressUpdates; i++) {
s_sleep(within(sleepTimeMs/kNumProgressUpdates));
base::Block<SplitInfo>* block;
queue->getWriteSlot(&block);
block->data.type = SplitInfo::PROGRESS_UPDATE;
block->data.bytesCompleted = request.start +
((i + 1) * bytesPerUpdate);
block->data.bytesTotal = request.end;
block->data.filename = request.filename;
queue->slotWritten(block);
}
//s_sleep(within(sleepTimeMs));
#else
base::ConfigurationMap conf;
conf["schemaUrl"] = request.schema;
conf["chunkStart"] = request.start;
conf["chunkEnd"] = request.end;
ddc_read(request.filename,
request.objectType,
conf);
return 0;
#endif
return 0; //status code
}
int main (int argc, char *argv[])
{
zmq::context_t context(1);
// Socket to receive messages on
zmq::socket_t receiver(context, ZMQ_PULL);
receiver.connect("tcp://localhost:5557");
// Socket to send messages to
zmq::socket_t sender(context, ZMQ_PUSH);
sender.connect("tcp://localhost:5558");
// Process tasks forever
while (1) {
zmq::message_t message;
int workload; // Workload in msecs
receiver.recv(&message);
std::string smessage(static_cast<char*>(message.data()), message.size());
std::istringstream iss(smessage);
iss >> workload;
// Do the work
s_sleep(workload);
// Send results to sink
message.rebuild();
sender.send(message);
// Simple progress indicator for the viewer
std::cout << "." << std::flush;
}
return 0;
}
int main () {
zmq::context_t context(1);
// Socket to talk to clients
zmq::socket_t publisher (context, ZMQ_PUB);
publisher.bind("tcp://*:5561");
// Socket to receive signals
zmq::socket_t syncservice (context, ZMQ_REP);
syncservice.bind("tcp://*:5562");
// Get synchronization from subscribers
int subscribers = 0;
while (subscribers < SUBSCRIBERS_EXPECTED) {
// - wait for synchronization request
s_recv (syncservice);
// - 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");
s_sleep (1000); // Give 0MQ time to flush output
return 0;
}
static void *
worker_task(void *args)
{
zmq::context_t context(1);
zmq::socket_t worker(context, ZMQ_DEALER);
#if (defined (WIN32))
s_set_id(worker, (intptr_t)args);
#else
s_set_id(worker); // Set a printable identity
#endif
worker.connect("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
s_recv(worker); // Envelope delimiter
std::string workload = s_recv(worker);
// .skip
if ("Fired!" == workload) {
std::cout << "Completed: " << total << " tasks" << std::endl;
break;
}
total++;
// Do some random work
s_sleep(within(500) + 1);
}
return NULL;
}
int main (void)
{
s_version_assert (2, 1);
srandom ((unsigned) time (NULL));
void *context = zmq_init (1);
void *worker = s_worker_socket (context);
// If liveness hits zero, queue is considered disconnected
size_t liveness = HEARTBEAT_LIVENESS;
size_t interval = INTERVAL_INIT;
// Send out heartbeats at regular intervals
uint64_t heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
int cycles = 0;
while (1) {
zmq_pollitem_t items [] = { { worker, 0, ZMQ_POLLIN, 0 } };
zmq_poll (items, 1, HEARTBEAT_INTERVAL * 1000);
if (items [0].revents & ZMQ_POLLIN) {
// Get message
// - 3-part envelope + content -> request
// - 1-part "HEARTBEAT" -> heartbeat
zmsg_t *msg = zmsg_recv (worker);
if (msg_parts (msg) == 3) {
// Simulate various problems, after a few cycles
cycles++;
if (cycles > 3 && randof (5) == 0) {
printf ("I: (%s) simulating a crash\n", identity);
zmsg_destroy (&msg);
break;
}
else
if (cycles > 3 && randof (5) == 0) {
printf ("I: (%s) simulating CPU overload\n", identity);
sleep (5);
}
printf ("I: (%s) normal reply - %s\n",
identity, zmsg_body (msg));
zmsg_send (&msg, worker);
liveness = HEARTBEAT_LIVENESS;
sleep (1); // Do some heavy work
}
else
if (msg_parts (msg) == 1
&& strcmp (msg_body (msg), "HEARTBEAT") == 0)
liveness = HEARTBEAT_LIVENESS;
else {
printf ("E: (%s) invalid message\n", identity);
zmsg_dump (msg);
}
interval = INTERVAL_INIT;
}
else
if (--liveness == 0) {
printf ("W: (%s) heartbeat failure, can't reach queue\n",
identity);
printf ("W: (%s) reconnecting in %zd msec...\n",
identity, interval);
s_sleep (interval);
if (interval < INTERVAL_MAX)
interval *= 2;
zmq_close (worker);
worker = s_worker_socket (context);
liveness = HEARTBEAT_LIVENESS;
}
// Send heartbeat to queue if it's time
if (s_clock () > heartbeat_at) {
heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
printf ("I: (%s) worker heartbeat\n", identity);
s_send (worker, "HEARTBEAT");
}
}
zmq_close (worker);
zmq_term (context);
return 0;
}
int main (void)
{
s_version_assert (2, 1);
srand ((unsigned) time (NULL));
zmq::context_t context (1);
zmq::socket_t * worker = s_worker_socket (context);
// If liveness hits zero, queue is considered disconnected
size_t liveness = HEARTBEAT_LIVENESS;
size_t interval = INTERVAL_INIT;
// Send out heartbeats at regular intervals
int64_t heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
int cycles = 0;
while (1) {
zmq::pollitem_t items [] = { { *worker, 0, ZMQ_POLLIN, 0 } };
zmq::poll (items, 1, HEARTBEAT_INTERVAL * 1000);
if (items [0].revents & ZMQ_POLLIN) {
// Get message
// - 3-part envelope + content -> request
// - 1-part "HEARTBEAT" -> heartbeat
zmsg msg (*worker);
if (msg.parts () == 3) {
// Simulate various problems, after a few cycles
cycles++;
if (cycles > 3 && within (5) == 0) {
std::cout << "I: (" << identity << ") simulating a crash" << std::endl;
msg.clear ();
break;
}
else {
if (cycles > 3 && within (5) == 0) {
std::cout << "I: (" << identity << ") simulating CPU overload" << std::endl;
s_sleep (5000);
}
}
std::cout << "I: (" << identity << ") normal reply - " << msg.body() << std::endl;
msg.send (*worker);
liveness = HEARTBEAT_LIVENESS;
s_sleep (1000); // Do some heavy work
}
else {
if (msg.parts () == 1
&& strcmp (msg.body (), "HEARTBEAT") == 0) {
liveness = HEARTBEAT_LIVENESS;
}
else {
std::cout << "E: (" << identity << ") invalid message" << std::endl;
msg.dump ();
}
}
interval = INTERVAL_INIT;
}
else
if (--liveness == 0) {
std::cout << "W: (" << identity << ") heartbeat failure, can't reach queue" << std::endl;
std::cout << "W: (" << identity << ") reconnecting in " << interval << " msec..." << std::endl;
s_sleep (interval);
if (interval < INTERVAL_MAX) {
interval *= 2;
}
delete worker;
worker = s_worker_socket (context);
liveness = HEARTBEAT_LIVENESS;
}
// Send heartbeat to queue if it's time
if (s_clock () > heartbeat_at) {
heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
std::cout << "I: (" << identity << ") worker heartbeat" << std::endl;
s_send (*worker, "HEARTBEAT");
}
}
delete worker;
return 0;
}
void cast_spell(int spell)
{
switch(spell) {
case S_MON_DET:
s_mondet();
break;
case S_OBJ_DET:
s_objdet();
break;
case S_IDENTIFY:
s_identify();
break;
case S_FIREBOLT:
s_firebolt();
break;
case S_SLEEP:
s_sleep();
break;
case S_LBALL:
s_lball();
break;
case S_TELEPORT:
s_teleport();
break;
case S_DISRUPT:
s_disrupt();
break;
case S_DISINTEGRATE:
s_disintegrate();
break;
case S_MISSILE:
s_missile();
break;
case S_HEAL:
s_heal();
break;
case S_DISPEL:
s_dispel();
break;
case S_BREATHE:
s_breathe();
break;
case S_INVISIBLE:
s_invisible();
break;
case S_WARP:
s_warp();
break;
case S_ENCHANT:
s_enchant();
break;
case S_BLESS:
s_bless();
break;
case S_RESTORE:
s_restore();
break;
case S_CURE:
s_cure();
break;
case S_TRUESIGHT:
s_truesight();
break;
case S_HELLFIRE:
s_hellfire();
break;
case S_KNOWLEDGE:
s_knowledge();
break;
case S_HERO:
s_hero();
break;
case S_RETURN:
s_return();
break;
case S_DESECRATE:
s_desecrate();
break;
case S_HASTE:
s_haste();
break;
case S_SUMMON:
s_summon();
break;
case S_SANCTUARY:
s_sanctuary();
break;
case S_ACCURACY:
s_accuracy();
break;
case S_RITUAL:
s_ritual();
break;
case S_APPORT:
s_apport();
break;
case S_SHADOWFORM:
s_shadowform();
break;
case S_ALERT:
s_alert();
break;
case S_REGENERATE:
s_regenerate();
break;
case S_SANCTIFY:
s_sanctify();
break;
case S_CLAIRVOYANCE:
s_clairvoyance();
break;
case S_DRAIN:
s_drain();
break;
case S_LEVITATE:
s_levitate();
break;
case S_FEAR:
s_fear();
break;
case S_POLYMORPH:
s_polymorph();
break;
case S_WISH:
s_wish();
break;
case S_NUTRITION:
s_nutrition();
break;
default:
mprint("Your odd spell fizzles with a small 'sput'.");
break;
}
}
int main ()
{
std::cout << "starting server..."<<std::endl;
fps = 25;
frameDuration = (int) round(1000.0 / (float) fps);
// Prepare our context and socket
zmq::context_t context(1);
zmq::socket_t socket(context, ZMQ_REP);
try {
socket.bind ("tcp://*:5555");
} catch (zmq::error_t error) {
std::cout << "Error Binding to address" << std::endl;
std::cout << error.what();
exit(1);
}
// starting kinect
if (initKinect()==false) {
std::cout << "Kinect Init Failed. Quiting..." << std::endl;
exit(2);
}
int bufferSize = 3*640*480;
char *depth=(char *)malloc(bufferSize);
memset(depth, 255, bufferSize);
kinectControl->setDepthMid(depth);
while (true) {
// Wait for next request from client
std::string request;
try {
request = s_recv(socket);
}
catch (zmq::error_t error) {
std::cout << "Error recieving message." << std::endl;
std::cout << error.what();
exit(1);
}
if (request.compare("getRGB") == 0) {
try {
uint8_t *rgb = kinectControl->getRGB();
zmq::message_t message(bufferSize);
memcpy(message.data(), rgb, bufferSize);
socket.send(message);
}
catch (zmq::error_t error) {
std::cout << "Error sending RGB image." << std::endl;
std::cout << error.what();
exit(1);
}
/*
uint8_t *rgb = kinectControl->getRGB();
s_send(socket, (char *) rgb);
*/
}
if (request.compare("getDepthmap") == 0) {
try {
zmq::message_t message(bufferSize);
memcpy(message.data(), depth, bufferSize);
socket.send(message);
}
catch (zmq::error_t error) {
std::cout << "Error sending depth image." << std::endl;
std::cout << error.what();
exit(1);
}
}
//usleep(frameDuration);
s_sleep(frameDuration);
}
socket.close();
return 0;
}
zmsg *
recv (zmsg *&reply_p)
{
// Format and send the reply if we were provided one
zmsg *reply = reply_p;
assert (reply || !m_expect_reply);
if (reply) {
assert (m_reply_to.size()!=0);
reply->wrap (m_reply_to.c_str(), "");
m_reply_to = "";
send_to_broker ((char*)MDPW_REPLY, "", reply);
delete reply_p;
reply_p = 0;
}
m_expect_reply = true;
while (!s_interrupted) {
zmq::pollitem_t items [] = {
{ *m_worker, 0, ZMQ_POLLIN, 0 } };
zmq::poll (items, 1, m_heartbeat * 1000);
if (items [0].revents & ZMQ_POLLIN) {
zmsg *msg = new zmsg(*m_worker);
if (m_verbose) {
s_console ("I: received message from broker:");
msg->dump ();
}
m_liveness = HEARTBEAT_LIVENESS;
// Don't try to handle errors, just assert noisily
assert (msg->parts () >= 3);
std::basic_string<unsigned char> empty = msg->pop_front ();
assert (empty.compare((unsigned char *)"") == 0);
//assert (strcmp (empty, "") == 0);
//free (empty);
std::basic_string<unsigned char> header = msg->pop_front ();
assert (header.compare((unsigned char *)MDPW_WORKER) == 0);
//free (header);
std::string command = (char*) msg->pop_front ().c_str();
if (command.compare (MDPW_REQUEST) == 0) {
// We should pop and save as many addresses as there are
// up to a null part, but for now, just save one...
m_reply_to = msg->unwrap ();
return msg; // We have a request to process
}
else if (command.compare (MDPW_HEARTBEAT) == 0) {
// Do nothing for heartbeats
}
else if (command.compare (MDPW_DISCONNECT) == 0) {
connect_to_broker ();
}
else {
s_console ("E: invalid input message (%d)",
(int) *(command.c_str()));
msg->dump ();
}
delete msg;
}
else
if (--m_liveness == 0) {
if (m_verbose) {
s_console ("W: disconnected from broker - retrying...");
}
s_sleep (m_reconnect);
connect_to_broker ();
}
// Send HEARTBEAT if it's time
if (s_clock () > m_heartbeat_at) {
send_to_broker ((char*)MDPW_HEARTBEAT, "", NULL);
m_heartbeat_at = s_clock () + m_heartbeat;
}
}
if (s_interrupted)
printf ("W: interrupt received, killing worker...\n");
return NULL;
}
