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_; };