static void
handle_worker_final (client_t *self)
{
mdp_msg_t *msg = self->message;
mdp_msg_t *client_msg = mdp_msg_new();
// Set routing id, messageid, service, body
zframe_t *address = mdp_msg_address(msg);
mdp_msg_set_routing_id(client_msg, address);
mdp_msg_set_id(client_msg, MDP_MSG_CLIENT_FINAL);
const char *service_name = self->service_name;
mdp_msg_set_service(client_msg, service_name);
zmsg_t *body = mdp_msg_get_body(msg);
mdp_msg_set_body(client_msg, &body);
mdp_msg_send(client_msg, self->server->router);
// Add the worker back to the list of waiting workers.
char *identity = zframe_strhex(mdp_msg_routing_id(msg));
worker_t *worker =
(worker_t *) zhash_lookup(self->server->workers, identity);
assert(worker);
zlist_append(self->server->waiting, worker);
service_t *service = (service_t *) zhash_lookup(self->server->services,
worker->service->name);
assert(service);
zlist_append(service->waiting, worker);
zstr_free(&identity);
mdp_msg_destroy(&client_msg);
}
static void
handle_ready (client_t *self)
{
mdp_msg_t *msg = self->message;
const char *service_name = mdp_msg_service(msg);
// zsys_debug("handle_ready: service=%s\n", service_name);
zframe_t *routing_id = mdp_msg_routing_id(msg);
assert(routing_id);
char *identity = zframe_strhex(routing_id);
int worker_ready = (zhash_lookup(self->server->workers, identity) != NULL);
free(identity);
worker_t *worker = s_worker_require(self->server, routing_id);
if (worker_ready) // Not first command in session.
s_worker_delete(worker, 1);
else {
service_t *service = s_service_require(self->server, service_name);
worker->service = service;
zlist_append(service->broker->waiting, worker);
zlist_append(service->waiting, worker);
worker->service->workers++;
s_service_dispatch(service);
}
}
static void s_broker_worker_msg(broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert (zmsg_size(msg) >= 1); // At least, command
zframe_t *command = zmsg_pop(msg);
char *id_string = zframe_strhex(sender);
int worker_ready = (zhash_lookup(self->workers, id_string) != NULL);
free (id_string);
worker_t *worker = s_worker_require(self, sender);
if (zframe_streq(command, MDPW_READY)) {
if (worker_ready) { // Not first command in session
s_worker_delete(worker, 1);
// Додумать, по идеи синоним сердцебиения
} else {
if (zframe_size(sender) >= 4 && memcmp(zframe_data (sender), "mmi.", 4) == 0) {
s_worker_delete(worker, 1);
// Додумать, по идеи синоним сердцебиения
} else {
// Attach worker to service and mark as idle
zframe_t *service_frame = zmsg_pop(msg);
worker->service = s_service_require(self, service_frame);
worker->service->workers++;
s_worker_waiting(worker);
zframe_destroy(&service_frame);
}
}
} else if (zframe_streq(command, MDPW_REPLY)) {
if (worker_ready) {
// Remove and save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
zframe_t *client = zmsg_unwrap(msg);
zmsg_pushstr(msg, worker->service->name);
zmsg_pushstr(msg, MDPC_CLIENT);
zmsg_wrap(msg, client);
zmsg_send(&msg, self->socket);
s_worker_waiting(worker);
} else {
// Просто обрыв связи между воркером и брокером
// синоним сердцебиения
s_worker_delete(worker, 1);
}
} else if (zframe_streq(command, MDPW_HEARTBEAT)) {
if (worker_ready) {
worker->expiry = zclock_time () + HEARTBEAT_EXPIRY;
} else {
// Просто обрыв связи между воркером и брокером
// синоним сердцебиения
s_worker_delete(worker, 1);
}
} else if (zframe_streq (command, MDPW_DISCONNECT)) {
s_worker_delete(worker, 0);
} else {
zclock_log ("E: invalid input message");
zmsg_dump (msg);
}
free (command);
zmsg_destroy (&msg);
}
///
// Return frame data encoded as printable hex string, useful for 0MQ UUIDs.
// Caller must free string when finished with it.
QString QZframe::strhex ()
{
char *retStr_ = zframe_strhex (self);
QString rv = QString (retStr_);
free (retStr_);;
return rv;
}
static void
s_worker_process (broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert (zmsg_size (msg) >= 1); // At least, command
zframe_t *command = zmsg_pop (msg);
char *identity = zframe_strhex (sender);
int worker_ready = (zhash_lookup (self->workers, identity) != NULL);
free (identity);
worker_t *worker = s_worker_require (self, sender);
if (zframe_streq (command, MDPW_READY)) {
if (worker_ready) // Not first command in session
s_worker_delete (self, worker, 1);
else
if (zframe_size (sender) >= 4 // Reserved service name
&& memcmp (zframe_data (sender), "mmi.", 4) == 0)
s_worker_delete (self, worker, 1);
else {
// Attach worker to service and mark as idle
zframe_t *service_frame = zmsg_pop (msg);
worker->service = s_service_require (self, service_frame);
worker->service->workers++;
s_worker_waiting (self, worker);
zframe_destroy (&service_frame);
}
}
else
if (zframe_streq (command, MDPW_REPLY)) {
if (worker_ready) {
// Remove & save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
zframe_t *client = zmsg_unwrap (msg);
zmsg_pushstr (msg, worker->service->name);
zmsg_pushstr (msg, MDPC_CLIENT);
zmsg_wrap (msg, client);
zmsg_send (&msg, self->socket);
s_worker_waiting (self, worker);
}
else
s_worker_delete (self, worker, 1);
}
else
if (zframe_streq (command, MDPW_HEARTBEAT)) {
if (worker_ready)
worker->expiry = zclock_time () + HEARTBEAT_EXPIRY;
else
s_worker_delete (self, worker, 1);
}
else
if (zframe_streq (command, MDPW_DISCONNECT))
s_worker_delete (self, worker, 0);
else {
zclock_log ("E: invalid input message");
zmsg_dump (msg);
}
free (command);
zmsg_destroy (&msg);
}
JNIEXPORT jstring JNICALL
Java_org_zeromq_czmq_Zframe__1_1strhex (JNIEnv *env, jclass c, jlong self)
{
char *strhex_ = (char *) zframe_strhex ((zframe_t *) (intptr_t) self);
jstring return_string_ = (*env)->NewStringUTF (env, strhex_);
zstr_free (&strhex_);
return return_string_;
}
static worker_t *
s_worker_new (zframe_t *identity)
{
worker_t *self = (worker_t *)zmalloc(sizeof(worker_t));
self->identity = identity;
self->id_string = zframe_strhex(identity);
self->expiry = zclock_time() + HEARTBEAT_INTERVAL * HEARTBEAT_LIVENESS;
return self;
}
static void
s_broker_worker_msg(broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert(zmsg_size(msg) >= 1);
zframe_t *command = zmsg_pop(msg);
char *id_string = zframe_strhex(sender);
int worker_ready = (zhash_lookup(self->workers, id_string) != NULL);
free(id_string);
worker_t *worker = s_worker_require(self, sender);
if (zframe_streq(command, MDPW_READY)){
if (worker_ready)
s_worker_delete(worker, 1);
else
if (zframe_size(sender) >= 4 && memcmp(zframe_data(sender), "mmi.", 4) == 0)
s_worker_delete(worker, 1);
else {
zframe_t *service_frame = zmsg_pop(msg);
worker->service = s_service_require(self, service_frame);
worker->service->workers++;
s_worker_waiting(worker);
zframe_destroy(&service_frame);
}
}
else
if (zframe_streq(command, MDPW_REPLY)){
if (worker_ready){
zframe_t *client = zmsg_unwrap(msg);
zmsg_pushstr(msg, worker->service->name);
zmsg_pushstr(msg, MDPC_CLIENT);
zmsg_wrap(msg, client);
zmsg_send(&msg, self->socket);
s_worker_waiting(worker);
}
else
s_worker_delete(worker, 1);
}
else
if (zframe_streq(command, MDPW_HEARTBEAT)){
if (worker_ready)
worker->expiry = zclock_time() + HEARTBEAT_EXPIRY;
else
s_worker_delete(worker, 1);
}
else
if (zframe_streq(command, MDPW_DISCONNECT))
s_worker_delete(worker, 0);
else {
zclock_log("E: invalid input message");
zmsg_dump(msg);
}
free(command);
zmsg_destroy(&msg);
}
static client_t *
client_new (agent_t *agent, zframe_t *address)
{
client_t *self = (client_t *) zmalloc (sizeof (client_t));
assert (self);
self->agent = agent;
self->codec = curve_codec_new_server (agent->cert, agent->ctx);
self->address = zframe_dup (address);
self->hashkey = zframe_strhex (address);
return self;
}
static client_t *
client_new (zframe_t *address)
{
client_t *self = (client_t *) zmalloc (sizeof (client_t));
self->state = start_state;
self->hashkey = zframe_strhex (address);
self->address = zframe_dup (address);
self->reply = fmq_msg_new (0);
fmq_msg_set_address (self->reply, self->address);
self->patches = zlist_new ();
return self;
}
static void
delete_worker (client_t *self)
{
mdp_msg_t *msg = self->message;
zframe_t *routing_id = mdp_msg_routing_id(msg);
assert(routing_id);
char *identity = zframe_strhex(routing_id);
worker_t *worker = (worker_t *) zhash_lookup(self->server->workers, identity);
free(identity);
if (worker != NULL)
s_worker_delete(worker, 0);
}
static void
server_client_message (server_t *self)
{
fmq_msg_t *request = fmq_msg_recv (self->router);
if (!request)
return; // Interrupted; do nothing
char *hashkey = zframe_strhex (fmq_msg_address (request));
client_t *client = zhash_lookup (self->clients, hashkey);
if (client == NULL) {
client = client_new (fmq_msg_address (request));
client->heartbeat = self->heartbeat;
client->router = self->router;
zhash_insert (self->clients, hashkey, client);
zhash_freefn (self->clients, hashkey, client_free);
}
free (hashkey);
if (client->request)
fmq_msg_destroy (&client->request);
client->request = request;
// Any input from client counts as heartbeat
client->heartbeat_at = zclock_time () + client->heartbeat;
// Any input from client counts as activity
client->expires_at = zclock_time () + client->heartbeat * 3;
if (fmq_msg_id (request) == FMQ_MSG_OHAI)
server_client_execute (self, client, ohai_event);
else
if (fmq_msg_id (request) == FMQ_MSG_YARLY)
server_client_execute (self, client, yarly_event);
else
if (fmq_msg_id (request) == FMQ_MSG_ICANHAZ)
server_client_execute (self, client, icanhaz_event);
else
if (fmq_msg_id (request) == FMQ_MSG_NOM)
server_client_execute (self, client, nom_event);
else
if (fmq_msg_id (request) == FMQ_MSG_HUGZ)
server_client_execute (self, client, hugz_event);
else
if (fmq_msg_id (request) == FMQ_MSG_KTHXBAI)
server_client_execute (self, client, kthxbai_event);
}
static worker_t *
s_worker_require(broker_t *self, zframe_t *identity)
{
assert(identity);
char *id_string = zframe_strhex(identity);
worker_t *worker = (worker_t *)zhash_lookup(self->workers, id_string);
if (worker == NULL){
worker = (worker_t *)zmalloc(sizeof(worker_t));
worker->broker = self;
worker->id_string = id_string;
worker->identity = zframe_dup(identity);
zhash_insert(self->workers, id_string, worker);
zhash_freefn(self->workers, id_string, s_worker_destroy);
if (self->verbose)
zclock_log("I: registering new worker: %s", id_string);
}
else
free(id_string);
return worker;
}
static void
agent_client_message (agent_t *self)
{
zmsg_t *msg = zmsg_recv (self->router);
if (!msg)
return; // Interrupted; do nothing
puts ("Received message from client");
zmsg_dump (msg);
// Frame 0 is address client that sent message
zframe_t *address = zmsg_pop (msg);
char *hashkey = zframe_strhex (address);
client_t *client = zhash_lookup (self->clients, hashkey);
if (client == NULL) {
client = client_new (self->router, hashkey, address);
zhash_insert (self->clients, hashkey, client);
zhash_freefn (self->clients, hashkey, client_free);
}
else {
free (hashkey);
zframe_destroy (&address);
}
// Frame 1 is the command
char *command = zmsg_popstr (msg);
client_set_request (client, msg);
if (command) {
if (streq (command, "OHAI"))
client_execute (client, ohai_event);
else
if (streq (command, "ICANHAZ"))
client_execute (client, icanhaz_event);
else
if (streq (command, "HUGZ"))
client_execute (client, hugz_event);
free (command);
}
}
static worker_t *
s_worker_require (broker_t *self, zframe_t *address)
{
assert (address);
// self->workers is keyed off worker identity
char *identity = zframe_strhex (address);
worker_t *worker =
(worker_t *) zhash_lookup (self->workers, identity);
if (worker == NULL) {
worker = (worker_t *) zmalloc (sizeof (worker_t));
worker->identity = identity;
worker->address = zframe_dup (address);
zhash_insert (self->workers, identity, worker);
zhash_freefn (self->workers, identity, s_worker_destroy);
if (self->verbose)
zclock_log ("I: registering new worker: %s", identity);
}
else
free (identity);
return worker;
}
static VALUE rb_czmq_frame_strhex(VALUE obj)
{
ZmqGetFrame(obj);
return rb_str_new2(zframe_strhex(frame));
}
static int
s_agent_handle_router (agent_t *self)
{
zframe_t *address = zframe_recv (self->router);
char *hashkey = zframe_strhex (address);
client_t *client = (client_t *) zhash_lookup (self->clients, hashkey);
if (client == NULL
&& self->nbr_pending < self->max_pending) {
client = client_new (self, address);
client_set_pending (client);
curve_codec_set_verbose (client->codec, self->verbose);
zhash_foreach (self->metadata, client_set_metadata, client);
zhash_insert (self->clients, hashkey, client);
zhash_freefn (self->clients, hashkey, client_free);
}
free (hashkey);
zframe_destroy (&address);
// If we're overloaded, discard client request without any further
// ado. The client will have to detect this and retry later.
// TODO: retry in client side to handle overloaded servers.
if (client == NULL)
return 0;
// If not yet connected, process one command frame
// We always read one request, and send one reply
if (client->state == pending) {
zframe_t *input = zframe_recv (self->router);
zframe_t *output = curve_codec_execute (client->codec, &input);
if (output) {
zframe_send (&client->address, self->router, ZFRAME_MORE + ZFRAME_REUSE);
zframe_send (&output, self->router, 0);
if (curve_codec_connected (client->codec))
client_set_connected (client);
}
else
client_set_exception (client);
}
else
// If connected, process one message frame
// We will queue message frames in the client until we get a
// whole message ready to deliver up the data socket -- frames
// from different clients will be randomly intermixed.
if (client->state == connected) {
zframe_t *encrypted = zframe_recv (self->router);
zframe_t *cleartext = curve_codec_decode (client->codec, &encrypted);
if (cleartext) {
if (client->incoming == NULL)
client->incoming = zmsg_new ();
zmsg_add (client->incoming, cleartext);
if (!zframe_more (cleartext)) {
zmsg_pushstr (client->incoming, client->hashkey);
zmsg_send (&client->incoming, self->data);
}
}
else
client_set_exception (client);
}
// If client is misbehaving, remove it
if (client->state == exception)
zhash_delete (self->clients, client->hashkey);
return 0;
}
///
// Return frame data encoded as printable hex string, useful for 0MQ UUIDs.
// Caller must free string when finished with it.
QString QmlZframe::strhex () {
char *retStr_ = zframe_strhex (self);
QString retQStr_ = QString (retStr_);
free (retStr_);
return retQStr_;
};
