static void
s_engine_handle_sell_request (engine_t *self, zframe_t *price,
zframe_t *volume, zframe_t *reply_to)
{
char *price_str = zframe_strdup (price);
char *volume_str = zframe_strdup (volume);
order_t *sell_order = s_order_new (self->worker,
atoi (price_str), atoi (volume_str), reply_to);
free (price_str);
free (volume_str);
while (sell_order->volume) {
order_t *buy_order = s_engine_match_buy_order (self);
if (buy_order == NULL || buy_order->price < sell_order->price)
break;
int volume = MIN (sell_order->volume, buy_order->volume);
// Perform trade
s_order_update (sell_order, volume);
s_order_update (buy_order, volume);
if (buy_order->volume == 0) {
zlist_remove (self->buy_orders, buy_order);
s_order_destroy (&buy_order);
}
}
if (sell_order->volume == 0)
s_order_destroy (&sell_order);
else
zlist_append (self->sell_orders, sell_order);
}
static service_t *
s_service_require (broker_t *self, zframe_t *service_frame)
{
assert (service_frame);
char *name = zframe_strdup (service_frame);
service_t *service =
(service_t *) zhash_lookup (self->services, name);
if (service == NULL) {
service = (service_t *) zmalloc (sizeof (service_t));
service->broker = self;
service->name = name;
service->requests = zlist_new ();
service->waiting = zlist_new ();
service->blacklist = zlist_new ();
zhash_insert (self->services, name, service);
zhash_freefn (self->services, name, s_service_destroy);
if (self->verbose)
zclock_log ("I: added service: %s", name);
}
else
free (name);
return service;
}
///
// Return frame data copied into freshly allocated string
// Caller must free string when finished with it.
QString QZframe::strdup ()
{
char *retStr_ = zframe_strdup (self);
QString rv = QString (retStr_);
free (retStr_);;
return rv;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdcli_t *session = mdcli_new ("tcp://localhost:5555", verbose);
zmsg_t *request;
zmsg_t *reply;
int count;
//for (count = 0; count < 1; count++) {
request = zmsg_new ();
zmsg_pushstr (request, "KILL");
reply = mdcli_send (session, "echo", &request);
if (reply)
{
zframe_t * lastFrame = zmsg_last(reply);
char* msg = zframe_strdup(lastFrame);
printf("msg:%s\n", msg);
printf("size:%d\n", zmsg_content_size(reply));
//zframe_print(lastFrame,"->");
zmsg_destroy (&reply);
}
//else
// break; // Interrupt or failure
//}
//printf ("%d requests/replies processed\n", count);
mdcli_destroy (&session);
return 0;
}
static
int process_meta_information_and_handle_heartbeat(subscriber_state_t *state, zmsg_t* msg)
{
zframe_t *first = zmsg_first(msg);
char *pub_spec = NULL;
bool is_heartbeat = zframe_streq(first, "heartbeat");
msg_meta_t meta;
int rc = msg_extract_meta_info(msg, &meta);
if (!rc) {
// dump_meta_info(&meta);
if (!state->meta_info_failures++)
fprintf(stderr, "[E] subscriber: received invalid meta info\n");
return is_heartbeat;
}
if (meta.device_number == 0) {
// ignore device number 0
state->messages_dev_zero++;
return is_heartbeat;
}
if (is_heartbeat) {
if (debug)
printf("received heartbeat from device %d\n", meta.device_number);
zmsg_first(msg); // msg_extract_meta_info repositions the pointer, so reset
zframe_t *spec_frame = zmsg_next(msg);
pub_spec = zframe_strdup(spec_frame);
}
state->message_gap_size += device_tracker_calculate_gap(state->tracker, &meta, pub_spec);
return is_heartbeat;
}
static void
s_broker_client_msg(broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert(zmsg_size(msg) >= 2);
zframe_t *service_frame = zmsg_pop(msg);
service_t *service = s_service_require(self, service_frame);
zmsg_wrap(msg, zframe_dup(sender));
if (zframe_size(service_frame) >= 4 && memcmp(zframe_data(service_frame), "mmi.", 4) == 0){
char *return_code;
if (zframe_streq(service_frame, "mmi.service")){
char *name = zframe_strdup(zmsg_last(msg));
service_t *service = (service_t *)zhash_lookup(self->services, name);
return_code = service && service->workers ? "200" : "404";
free(name);
}
else
return_code = "501";
zframe_reset(zmsg_last(msg), return_code, strlen(return_code));
zframe_t *client = zmsg_unwrap(msg);
zmsg_prepend(msg, &service_frame);
zmsg_pushstr(msg, MDPC_CLIENT);
zmsg_wrap(msg, client);
zmsg_send(&msg, self->socket);
}
else
s_service_dispatch(service, msg);
zframe_destroy(&service_frame);
}
zmsg_t *
mdp_client_recv (mdp_client_t *self, char **command_p, char **service_p)
{
assert (self);
zmsg_t *msg = zmsg_recv (self->client);
if (msg == NULL)
// Interrupt
return NULL;
if (self->verbose) {
zclock_log ("I: received reply:");
zmsg_dump (msg);
}
// Message format:
// Frame 1: empty frame (delimiter)
// Frame 2: "MDPCxy" (six bytes, MDP/Client x.y)
// Frame 3: REPORT|NAK
// Frame 4: Service name (printable string)
// Frame 5..n: Application frames
// We would handle malformed replies better in real code
assert (zmsg_size (msg) >= 5);
zframe_t *empty = zmsg_pop (msg);
assert (zframe_streq (empty, ""));
zframe_destroy (&empty);
zframe_t *header = zmsg_pop (msg);
assert (zframe_streq (header, MDPC_CLIENT));
zframe_destroy (&header);
zframe_t *command = zmsg_pop (msg);
assert (zframe_streq (command, MDPC_REPORT) ||
zframe_streq (command, MDPC_NAK));
if (command_p)
*command_p = zframe_strdup (command);
zframe_destroy (&command);
zframe_t *service = zmsg_pop (msg);
if (service_p)
*service_p = zframe_strdup (service);
zframe_destroy (&service);
return msg; // Success
}
JNIEXPORT jstring JNICALL
Java_org_zeromq_czmq_Zframe__1_1strdup (JNIEnv *env, jclass c, jlong self)
{
char *strdup_ = (char *) zframe_strdup ((zframe_t *) (intptr_t) self);
jstring return_string_ = (*env)->NewStringUTF (env, strdup_);
zstr_free (&strdup_);
return return_string_;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdp_client_t *client = mdp_client_new ("tcp://localhost:5555", verbose);
// Send 100 sell orders
int count;
for (count = 0; count < 5; count++) {
zmsg_t *request = zmsg_new ();
zmsg_pushstr (request, "8"); // volume
zmsg_pushstr (request, "%d", count + 1000); // price
zmsg_pushstr (request, "SELL");
mdp_client_send (client, "NYSE", &request);
}
// Send 1 buy order.
// This order will match all sell orders.
zmsg_t *request = zmsg_new ();
zmsg_pushstr (request, "800"); // volume
zmsg_pushstr (request, "2000"); // price
zmsg_pushstr (request, "BUY");
mdp_client_send (client, "NYSE", &request);
// Wait for all trading reports
while (1) {
char *service = NULL;
zmsg_t *report = mdp_client_recv (client, &service);
if (report == NULL)
break;
assert (zmsg_size (report) >= 2);
zframe_t *report_type = zmsg_pop (report);
char *report_type_str = zframe_strdup (report_type);
zframe_t *volume = zmsg_pop (report);
char *volume_str = zframe_strdup (volume);
printf ("%s: %s %s shares\n", service, report_type_str, volume_str);
free (service);
free (report_type_str);
free (volume_str);
}
mdp_client_destroy (&client);
return 0;
}
// Construct new worker
static worker_t *
s_worker_new (zframe_t *address)
{
worker_t *self = (worker_t *) zmalloc (sizeof (worker_t));
self->address = address;
self->identity = zframe_strdup (address);
self->expiry = zclock_time () + HEARTBEAT_INTERVAL * HEARTBEAT_LIVENESS;
return self;
}
// Construct new worker
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_strdup (identity);
self->expiry = zclock_time ()
+ HEARTBEAT_INTERVAL * HEARTBEAT_LIVENESS;
return self;
}
int main(int argc, char const * const *argv)
{
int rc;
zctx_t *context = zctx_new();
assert(context);
zctx_set_rcvhwm(context, 1000);
zctx_set_linger(context, 100);
void *socket = zsocket_new(context, ZMQ_PULL);
assert(socket);
zsocket_set_rcvhwm(socket, 100000);
zsocket_set_linger(socket, 500);
zsocket_set_reconnect_ivl(socket, 100); // 100 ms
zsocket_set_reconnect_ivl_max(socket, 10 * 1000); // 10 s
const char* host = "localhost";
if (argc>1) host = argv[1];
rc = zsocket_connect(socket, "tcp://%s:9651", host);
assert(rc==0);
zmsg_t *msg = NULL;
size_t received = 0;
size_t lost = 0;
size_t last_num = 0;
while (1) {
msg = zmsg_recv(socket);
if (zsys_interrupted)
break;
assert(msg);
received++;
// assert(zmsg_size(msg) == 3);
// zmsg_dump(msg);
zframe_t *last_frame = zmsg_last(msg);
char *str = zframe_strdup(last_frame);
size_t n = atol(str);
free(str);
if (n > last_num + 1 && last_num != 0) {
lost += n - (last_num + 1);
}
last_num = n;
zmsg_destroy(&msg);
}
zsocket_destroy(context, socket);
zctx_destroy(&context);
printf("\nlost: %7zu\nreceived: %7zu\n", lost, received);
return 0;
}
int main (int argc, char *argv [])
{
zmsg_t *reply = 0;
mdwrk_t *session = 0;
zframe_t * lastFrame = 0;
char* lastMsg = 0;
int verbose = (argc > 1 && streq (argv [1], "-v"));
//if (argc = 2 && !streq (argv [1], "-v"))
//{
// session = mdwrk_new ("tcp://localhost:5555", argv[1], verbose);
//}
//else if (argc = 3 && !streq (argv [2], ""))
//{
// session = mdwrk_new ("tcp://localhost:5555", argv[2], verbose);
//}
//else
//{
session = mdwrk_new ("tcp://localhost:5555", "echo", verbose);
//}
if (!session) return 1;
while (true) {
zmsg_t *request = mdwrk_recv (session, &reply);
if (request == NULL) break; // Worker was interrupted
////////////////////////////////////加入自己的雷达逻辑//////////////////////////////////
//解析收到的信息
lastFrame = zmsg_last(request);
lastMsg = zframe_strdup(lastFrame);
printf("zmsg_t::msg:%s\n", lastMsg);
printf("zmsg_t::size:%d\n", zmsg_content_size(request));
//
//
//
//
//建立回复信息
reply = zmsg_new ();
zmsg_pushstr (reply, "Done！");
////////////////////////////////////////////////////////////////////////////////////////
zmsg_destroy (&request);
//reply = request; // Echo is complex... :-)
}
mdwrk_destroy (&session);
return 0;
}
char *
zmsg_popstr (zmsg_t *self)
{
assert (self);
zframe_t *frame = (zframe_t *) zlist_pop (self->frames);
char *string = NULL;
if (frame) {
self->content_size -= zframe_size (frame);
string = zframe_strdup (frame);
zframe_destroy (&frame);
}
return string;
}
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 ();
zmsg_addstr (request, "echo");
zmsg_addstr (request, "Hello world");
zmsg_t *reply = s_service_call (
session, "titanic.request", &request);
zframe_t *uuid = NULL;
if (reply) {
uuid = zmsg_pop (reply);
zmsg_destroy (&reply);
zframe_print (uuid, "I: request UUID ");
}
// 2. Wait until we get a reply
while (!zctx_interrupted) {
zclock_sleep (100);
request = zmsg_new ();
zmsg_add (request, zframe_dup (uuid));
zmsg_t *reply = s_service_call (
session, "titanic.reply", &request);
if (reply) {
char *reply_string = zframe_strdup (zmsg_last (reply));
printf ("Reply: %s\n", reply_string);
free (reply_string);
zmsg_destroy (&reply);
// 3. Close request
request = zmsg_new ();
zmsg_add (request, zframe_dup (uuid));
reply = s_service_call (session, "titanic.close", &request);
zmsg_destroy (&reply);
break;
}
else {
printf ("I: no reply yet, trying again...\n");
zclock_sleep (5000); // Try again in 5 seconds
}
}
zframe_destroy (&uuid);
mdcli_destroy (&session);
return 0;
}
static void s_broker_client_msg(broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert (zmsg_size(msg) >= 2); // Service name + body
zframe_t *service_frame = zmsg_pop(msg);
service_t *service = s_service_require(self, service_frame);
// Не должен создавать сервис, в случаи запроса от клиента
// Set reply return identity to client sender
zmsg_wrap(msg, zframe_dup(sender));
// If we got a MMI service request, process that internally
if (zframe_size(service_frame) >= 4 && memcmp(zframe_data(service_frame), "mmi.", 4) == 0) {
char *return_code;
if (zframe_streq(service_frame, "mmi.service")) {
char *name = zframe_strdup (zmsg_last (msg));
service_t *service = (service_t *) zhash_lookup(self->services, name);
if (service) {
if (service->workers) {
return_code = "200";
} else {
return_code = "404";
}
} else {
return_code = "401";
}
free(name);
} else {
return_code = "501";
}
zframe_reset(zmsg_last(msg), return_code, strlen(return_code));
// Remove & save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
zframe_t *client = zmsg_unwrap (msg);
zmsg_push(msg, zframe_dup(service_frame));
zmsg_pushstr(msg, MDPC_CLIENT);
zmsg_wrap(msg, client);
zmsg_send(&msg, self->socket);
} else {
// Else dispatch the message to the requested service
s_service_dispatch(service, msg);
}
zframe_destroy(&service_frame);
}
/**
* @brief Receives data through the given 0mq socket and sticks it into buf.
*
* This function is blocking.
*
* @returns Number of bytes read.
*
* @param buf Pointer to a void* buffer.
*/
int mux_0mq_recv_msg(void **buf)
{
zmsg_t *msg = NULL;
zframe_t *identity = NULL;
zframe_t *data = NULL;
int len = -1;
mux_printf("Now blocking on recv");
if ((msg = zmsg_recv(display->zmq.socket)) == NULL) {
mux_printf_error("Could not receive message from socket!");
return -1;
}
//zmsg_print(msg);
identity = zmsg_pop(msg);
//zframe_print(identity, "F: ");
if (!zframe_streq(identity, display->uuid)) {
char *wrong = zframe_strdup(identity);
mux_printf_error("Incorrect UUID: %s", wrong);
free(wrong);
zframe_destroy(&identity);
return -1;
}
data = zmsg_pop(msg);
//zframe_print(data, "F: ");
len = zframe_size(data);
*buf = calloc(1, zframe_size(data) + 1);
memcpy(*buf, zframe_data(data), zframe_size(data));
zframe_destroy(&identity);
zframe_destroy(&data);
return len;
}
void
zchanneler_test (bool verbose)
{
printf (" * zchanneler: ");
// @selftest
// Simple create/destroy test
zchanneler_t *self = zchanneler_new ("inproc://test");
assert (self);
zframe_t *sent = zframe_new ("hello", 5);
int rc = zchanneler_send (self, sent, 0);
assert (rc == 0);
zframe_t *received = zchanneler_recv(self);
char *got = zframe_strdup (received);
assert (!strcmp(got, "hello"));
zframe_destroy (&received);
zchanneler_destroy (&self);
// @end
printf ("OK\n");
}
static void
s_service_internal (broker_t *self, zframe_t *service_frame, zmsg_t *msg)
{
char *return_code;
if (zframe_streq (service_frame, "mmi.service")) {
char *name = zframe_strdup (zmsg_last (msg));
service_t *service =
(service_t *) zhash_lookup (self->services, name);
return_code = service && service->workers? "200": "404";
free (name);
}
else
return_code = "501";
zframe_reset (zmsg_last (msg), return_code, strlen (return_code));
// Remove & save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
zframe_t *client = zmsg_unwrap (msg);
zmsg_push (msg, zframe_dup (service_frame));
zmsg_pushstr (msg, MDPC_CLIENT);
zmsg_wrap (msg, client);
zmsg_send (&msg, self->socket);
}
static void
handle_frontend (GPPWorker *self)
{
GPPWorkerPrivate *priv = GET_PRIV (self);
GPPWorkerClass *klass = GPP_WORKER_GET_CLASS (self);
zmsg_t *msg = zmsg_recv (priv->frontend);
if (!msg)
return;
if (zmsg_size (msg) == 3) {
char *request = zframe_strdup (zmsg_last (msg));
g_info ("I: normal reply\n");
priv->liveness = HEARTBEAT_LIVENESS;
priv->current_task = msg;
if (!klass->handle_request (self, request))
gpp_worker_set_task_done (self, NULL, FALSE);
free (request);
} else {
if (zmsg_size (msg) == 1) {
zframe_t *frame = zmsg_first (msg);
if (memcmp (zframe_data (frame), PPP_HEARTBEAT, 1) == 0) {
priv->liveness = HEARTBEAT_LIVENESS;
g_debug ("got heartbeat from queue !\n");
} else {
g_warning ("E: invalid message\n");
zmsg_dump (msg);
}
zmsg_destroy (&msg);
}
else {
g_warning ("E: invalid message\n");
zmsg_dump (msg);
}
}
priv->interval = INTERVAL_INIT;
}
void
broker_run (broker_t *self)
{
// Only accepting requests when executors available.
bool accepting_requests = false;
while (1) {
zsock_t *which = (zsock_t *) zpoller_wait (self->poller, 10);
if (which == self->contexts) {
puts ("[BROKER] which == self->contexts");
// [context] [request]
zmsg_t *msg = zmsg_recv (self->contexts);
assert (msg);
if (0 != broker_send_to_executor (self, msg))
zlist_append (self->backlog, msg);
// Remove contexts from poller if no executors
if (zlist_size (self->executor_lb) == 0) {
zpoller_remove (self->poller, self->contexts);
accepting_requests = false;
}
}
else if (which == self->executors) {
puts ("[BROKER] which == self->executors");
// EITHER:
// [executor] ["READY"]
// [executor] [context] [response]
zmsg_t *msg = zmsg_recv (self->executors);
assert (msg);
zframe_t *executor_addr = zmsg_pop (msg);
assert (executor_addr);
zframe_t *ctx_or_ready = zmsg_pop (msg);
char *context_addr = zframe_strdup (ctx_or_ready);
if (strcmp (context_addr, "READY") != 0) {
// Forward the response to the correct context addr.
// [context] [0] [response]
zmsg_prepend (msg, &ctx_or_ready);
zmsg_send (&msg, self->contexts);
} else {
// Got a READY message
// Put the executor ID back in the available queue
zlist_append (self->executor_lb, executor_addr);
// We know at least one executor is now available,
// so check and assign backlog tasks.
broker_check_backlog (self);
// If we now have executors but not accepting requests,
// then start polling on the frontend socket.
if (!accepting_requests && zlist_size (self->executor_lb)) {
zpoller_add (self->poller, self->contexts);
accepting_requests = true;
}
// Destroy the READY message.
zmsg_destroy (&msg);
}
}
else if (zpoller_terminated (self->poller))
break;
}
}
void*
thread_recv(void* args){
assert(args);
assert(g_apex_cfg);
assert(g_zmq_context);
char* broker = (char*)args;
char temp[256];
sprintf(temp, "%s", broker);
char* host = strtok(temp, ":");
char* portstr = strtok(NULL, ":");
assert(host);
assert(portstr);
int port = atoi(portstr);
zbusconn_cfg_t conn_cfg;
memset(&conn_cfg, 0, sizeof(conn_cfg));
conn_cfg.ctx = g_zmq_context;
conn_cfg.verbose = g_apex_cfg->debug;
strcpy(conn_cfg.host, host);
conn_cfg.port = port;
zbusconn_t* zbus_conn = zbusconn_new(&conn_cfg);
zbuswrk_cfg_t wrk_cfg;
memset(&wrk_cfg, 0, sizeof(wrk_cfg));
strcpy(wrk_cfg.service, g_apex_cfg->service_name);
strcpy(wrk_cfg.reg_token, g_apex_cfg->service_regtoken);
strcpy(wrk_cfg.acc_token, g_apex_cfg->service_acctoken);
strcpy(wrk_cfg.mode, MODE_LB);
zbuswrk_t* worker = zbuswrk_new(&wrk_cfg);
assert(worker);
int rc;
char value_data[VALUE_MAX_LEN];
char msg_data[VALUE_MAX_LEN];
HANDLE_CONN apex_conn = Fix_Connect(g_apex_cfg->apex_address,
g_apex_cfg->apex_user,g_apex_cfg->apex_pwd, g_apex_cfg->apex_timeout);
if(apex_conn){
zlog("APEX Connected\n");
}
while(1){
while(!apex_conn){
zlog("APEX(%s) down, reconnecting...\n", g_apex_cfg->apex_address);
apex_conn = Fix_Connect(g_apex_cfg->apex_address,
g_apex_cfg->apex_user,g_apex_cfg->apex_pwd,g_apex_cfg->apex_timeout);
if(apex_conn){
zlog("APEX Connected\n");
}
zclock_sleep(g_apex_cfg->apex_reconnect);
}
zmsg_t* request = zbuswrk_recv(zbus_conn, worker);
if(!request) break;
zframe_t* sock_id, *msg_id;
zbuswrk_get_address(worker, &sock_id, &msg_id);
if(zmsg_frame_size(request) != 2){
zmsg_destroy(&request);
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("400"));
zmsg_push_back(reply, zframe_newstr("request format: <funcid> <json_params>"));
s_client_reply(zbus_conn, sock_id, msg_id, reply);
continue;
}
zframe_t* funcid_frame = zmsg_pop_front(request);
char* funcid_str = zframe_strdup(funcid_frame);
long funcid = atol(funcid_str);
zframe_t* params_frame = zmsg_pop_front(request);
char* params_json = zframe_strdup(params_frame);
HANDLE_SESSION sess = Fix_AllocateSession(apex_conn);
Fix_SetGYDM(sess, "99999998");
Fix_SetFBDM(sess, "9999");
Fix_CreateReq(sess, funcid);
cJSON* json = cJSON_Parse(params_json);
if(json){
cJSON* param = json->child;
while(param && param->string){
long key = atol(param->string);
char* val = param->valuestring;
if(!val) val = "";
char* val_utf8 = utf8_to_gbk(val);
Fix_SetString(sess, key, val_utf8);
delete[] val_utf8;
param = param->next;
}
cJSON_Delete(json);
} else {
zframe_destroy(&funcid_frame);
zfree(funcid_str);
zframe_destroy(¶ms_frame);
zfree(params_json);
zmsg_destroy(&request);
Fix_ReleaseSession(sess);
continue;
}
rc = Fix_Run(sess);
if(rc){
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("200"));
cJSON* root = cJSON_CreateArray();
int rows = Fix_GetCount(sess);
for(int i=0; i<rows; i++){
int cols = Fix_GetColumnCount(sess, i);
cJSON* row = cJSON_CreateObject();
for(int j=0; j<cols; j++){
long key = 0;
int size = VALUE_MAX_LEN;
Fix_GetValWithIdByIndex(sess, i, j, key, value_data, size);
char key_str[32];
sprintf(key_str, "%d", key);
value_data[size] = '\0';
char* value_data_utf8 = gbk_to_utf8(value_data);
cJSON_AddStringToObject(row, key_str, value_data_utf8);
delete[] value_data_utf8;
}
cJSON_AddItemToArray(root, row);
}
if(rows == 0){
Fix_GetItem(sess, FID_MESSAGE, msg_data, sizeof(msg_data));
root->valuestring = msg_data;
}
char* json_data = cJSON_Print(root);
zmsg_push_back(reply, zframe_newstr(json_data));
free(json_data);
s_client_reply(zbus_conn, sock_id, msg_id, reply);
} else {
long code = Fix_GetCode(sess);
Fix_GetErrMsg(sess, msg_data, sizeof(msg_data));
zlog("WARN: APEX failed(code=%d,msg=%s)\n", code, msg_data);
zmsg_t* reply = zmsg_new();
zmsg_push_back(reply, zframe_newstr("500"));
zmsg_push_back(reply, zframe_newstr(msg_data));
s_client_reply(zbus_conn, sock_id, msg_id, reply);
zframe_destroy(&sock_id);
zframe_destroy(&msg_id);
}
Fix_ReleaseSession(sess);
zframe_destroy(&funcid_frame);
zfree(funcid_str);
zframe_destroy(¶ms_frame);
zfree(params_json);
zmsg_destroy(&request);
}
zfree(broker);
zbusconn_destroy(&zbus_conn);
Fix_Close(apex_conn);
return NULL;
}
Z K1(zframestrdup){PC(x); R ks(zframe_strdup(VSK(x)));}
static int
agent_recv_from_peer (agent_t *self)
{
// Router socket tells us the identity of this peer
zre_msg_t *msg = zre_msg_recv (self->inbox);
if (msg == NULL)
return 0; // Interrupted
char *identity = zframe_strdup (zre_msg_address (msg));
// On HELLO we may create the peer if it's unknown
// On other commands the peer must already exist
zre_peer_t *peer = (zre_peer_t *) zhash_lookup (self->peers, identity);
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
peer = s_require_peer (
self, identity, zre_msg_ipaddress (msg), zre_msg_mailbox (msg));
assert (peer);
zre_peer_ready_set (peer, true);
}
// Ignore command if peer isn't ready
if (peer == NULL || !zre_peer_ready (peer)) {
free(identity);
zre_msg_destroy (&msg);
return 0;
}
if (!zre_peer_check_message (peer, msg)) {
zclock_log ("W: [%s] lost messages from %s", self->identity, identity);
assert (false);
}
// Now process each command
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
// Join peer to listed groups
char *name = zre_msg_groups_first (msg);
while (name) {
s_join_peer_group (self, peer, name);
name = zre_msg_groups_next (msg);
}
// Hello command holds latest status of peer
zre_peer_status_set (peer, zre_msg_status (msg));
// Store peer headers for future reference
zre_peer_headers_set (peer, zre_msg_headers (msg));
// If peer is a ZRE/LOG collector, connect to it
char *collector = zre_msg_headers_string (msg, "X-ZRELOG", NULL);
if (collector)
zre_log_connect (self->log, collector);
// If peer is a FileMQ publisher, connect to it
char *publisher = zre_msg_headers_string (msg, "X-FILEMQ", NULL);
if (publisher)
fmq_client_connect (self->fmq_client, publisher);
}
else
if (zre_msg_id (msg) == ZRE_MSG_WHISPER) {
// Pass up to caller API as WHISPER event
zframe_t *cookie = zre_msg_content (msg);
zstr_sendm (self->pipe, "WHISPER");
zstr_sendm (self->pipe, identity);
zframe_send (&cookie, self->pipe, ZFRAME_REUSE); // let msg free the frame
}
else
if (zre_msg_id (msg) == ZRE_MSG_SHOUT) {
// Pass up to caller as SHOUT event
zframe_t *cookie = zre_msg_content (msg);
zstr_sendm (self->pipe, "SHOUT");
zstr_sendm (self->pipe, identity);
zstr_sendm (self->pipe, zre_msg_group (msg));
zframe_send (&cookie, self->pipe, ZFRAME_REUSE); // let msg free the frame
}
else
if (zre_msg_id (msg) == ZRE_MSG_PING) {
zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING_OK);
zre_peer_send (peer, &msg);
}
else
if (zre_msg_id (msg) == ZRE_MSG_JOIN) {
s_join_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zre_peer_status (peer));
}
else
if (zre_msg_id (msg) == ZRE_MSG_LEAVE) {
s_leave_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zre_peer_status (peer));
}
free (identity);
zre_msg_destroy (&msg);
// Activity from peer resets peer timers
zre_peer_refresh (peer);
return 0;
}
///
// Return frame data copied into freshly allocated string
// Caller must free string when finished with it.
QString QmlZframe::strdup () {
char *retStr_ = zframe_strdup (self);
QString retQStr_ = QString (retStr_);
free (retStr_);
return retQStr_;
};
void trigger(void *cvoid,
zctx_t * context,
void * control) {
triggerconfig_t * c = (triggerconfig_t*) cvoid;
//set up msgpack stuff
zclock_log("watch_port started!");
msgpack_zone mempool;
msgpack_zone_init(&mempool, 2048);
// TODO
char * user_id = "17";
// TODO get broker in somehow
char * broker = "tcp://au.ninjablocks.com:5773";
mdcli_t * client = mdcli_new(broker, 1); //VERBOSE
triggermemory_t trigger_memory;
msgpack_object * addins_obj = parse_msgpack(&mempool, c->addins);
if(!parse_addins(addins_obj, &trigger_memory)) {
//bad message
zclock_log("bad trigger definition");
msgpack_object_print(stdout, *addins_obj);
send_sync("bad trigger", control);
return;
}
zclock_log("Creating trigger: target %s, rule_id %s, name %s",
c->target_worker, c->rule_id, c->trigger_name);
dump_trigger(&trigger_memory);
triggerfunction trigger_func;
if(!(trigger_func = find_trigger(c->channel, c->trigger_name))) {
zclock_log("no trigger found for channel %s, trigger %s",
c->channel, c->trigger_name);
send_sync("no such trigger", control);
return;
}
void * line = zsocket_new(context, ZMQ_SUB);
// what line are we on?
// this comes in the addins.
char * linesocket = to_linesocket(trigger_memory.line_id);
zclock_log("trigger is connecting to listen on %s", linesocket);
zsocket_connect(line, linesocket);
zsockopt_set_unsubscribe(line, "");
zsockopt_set_subscribe(line, "VALUE");
recv_sync("ping", control);
send_sync("pong", control);
zmq_pollitem_t items [] = {
{ line, 0, ZMQ_POLLIN, 0 },
{ control, 0, ZMQ_POLLIN, 0 }
};
while(1) {
// listen on control and line
zmq_poll (items, 2, -1);
if (items[1].revents & ZMQ_POLLIN) {
zclock_log("rule %s received message on control pipe", c->rule_id);
// control message
// really only expecting DESTROY
zmsg_t * msg = zmsg_recv(control);
char * str = zmsg_popstr(msg);
zmsg_destroy(&msg);
if (strcmp("Destroy", str) == 0) {
zclock_log("rule %s will quit on request", c->rule_id);
free(str);
send_sync("ok", control);
zclock_log("rule %s quitting on request", c->rule_id);
break;
} else {
zclock_log("unexpected command %s for rule %s", str, c->rule_id);
free(str);
send_sync("ok", control);
}
}
if (items[0].revents & ZMQ_POLLIN) {
// serial update
zmsg_t * msg = zmsg_recv(line);
zframe_t * cmd = zmsg_pop(msg);
if(zframe_streq(cmd, "CHANNEL_CHANGE")) {
// TODO
// must have been dormant to have gotten this
char * new_channel = zmsg_popstr(msg);
if(strcmp(c->channel, new_channel) == 0) {
// oh, happy day! We're relevant again.
// reactivate and start looking at reset levels.
zclock_log("line %d: changed channel from %s to %s: trigger coming back to life", trigger_memory.line_id, c->channel, new_channel);
zsockopt_set_subscribe(line, "VALUE");
zsockopt_set_unsubscribe(line, "CHANNEL_CHANGE");
}
free(new_channel);
} else if (zframe_streq(cmd, "VALUE")) {
zframe_t * vframe = zmsg_pop(msg);
int value;
memcpy(&value, zframe_data(vframe), sizeof(int));
char * update_channel = zmsg_popstr(msg);
if(strcmp(c->channel, update_channel) != 0) {
// channel changed, go dormant
// this is legit according to my tests at
// https://gist.github.com/2042350
zclock_log("line %d: changed channel from %s to %s: trigger going dormant", trigger_memory.line_id, c->channel, update_channel);
zsockopt_set_subscribe(line, "CHANNEL_CHANGE");
zsockopt_set_unsubscribe(line, "VALUE");
}
else if(trigger_func(&trigger_memory, value)) {
send_trigger(client, c->target_worker, c->rule_id, value, user_id);
}
free(update_channel);
} else {
// shouldn't ever happen.
zclock_log("shouldn't have received command %s\n", zframe_strdup(cmd));
}
zmsg_destroy(&msg);
zframe_destroy(&cmd);
}
}
msgpack_zone_destroy(&mempool);
}
bool zwshandshake_parse_request(zwshandshake_t *self, zframe_t* data)
{
// the parse method is not fully implemented and therefore not secured.
// for the purpose of ZWS prototyoe only the request-line, upgrade header and Sec-WebSocket-Key are validated.
char *request = zframe_strdup(data);
int length = strlen(request);
char *field_name;
char *field_value;
size_t name_begin, name_length, value_begin, value_length;
for (size_t i = 0; i < length; i++)
{
char c = request[i];
switch (self->state)
{
case initial:
if (c == 'G')
self->state = request_line_G;
else
self->state = error;
break;
case request_line_G:
if (c == 'E')
self->state = request_line_GE;
else
self->state = error;
break;
case request_line_GE:
if (c == 'T')
self->state = request_line_GET;
else
self->state = error;
break;
case request_line_GET:
if (c == ' ')
self->state = request_line_GET_space;
else
self->state = error;
break;
case request_line_GET_space:
if (c == '\r' || c == '\n')
self->state = error;
// TODO: instead of check what is not allowed check what is allowed
if (c != ' ')
self->state = request_line_resource;
else
self->state = request_line_GET_space;
break;
case request_line_resource:
if (c == '\r' || c == '\n')
self->state = error;
else if (c == ' ')
self->state = request_line_resource_space;
else
self->state = request_line_resource;
break;
case request_line_resource_space:
if (c == 'H')
self->state = request_line_H;
else
self->state = error;
break;
case request_line_H:
if (c == 'T')
self->state = request_line_HT;
else
self->state = error;
break;
case request_line_HT:
if (c == 'T')
self->state = request_line_HTT;
else
self->state = error;
break;
case request_line_HTT:
if (c == 'P')
self->state = request_line_HTTP;
else
self->state = error;
break;
case request_line_HTTP:
if (c == '/')
self->state = request_line_HTTP_slash;
else
self->state = error;
break;
case request_line_HTTP_slash:
if (c == '1')
self->state = request_line_HTTP_slash_1;
else
self->state = error;
break;
case request_line_HTTP_slash_1:
if (c == '.')
self->state = request_line_HTTP_slash_1_dot;
else
self->state = error;
break;
case request_line_HTTP_slash_1_dot:
if (c == '1')
self->state = request_line_HTTP_slash_1_dot_1;
else
self->state = error;
break;
case request_line_HTTP_slash_1_dot_1:
if (c == '\r')
self->state = request_line_cr;
else
self->state = error;
break;
case request_line_cr:
if (c == '\n')
self->state = header_field_begin_name;
else
self->state = error;
break;
case header_field_begin_name:
switch (c)
{
case '\r':
self->state = end_line_cr;
break;
case '\n':
self->state = error;
break;
default:
name_begin = i;
self->state = header_field_name;
break;
}
break;
case header_field_name:
if (c == '\r' || c == '\n')
self->state = error;
else if (c == ':')
{
name_length = i - name_begin;
self->state = header_field_colon;
}
else
self->state = header_field_name;
break;
case header_field_colon:
case header_field_value_trailing_space:
if (c == '\n')
self->state = error;
else if (c == '\r')
self->state = header_field_cr;
else if (c == ' ')
self->state = header_field_value_trailing_space;
else
{
value_begin = i;
self->state = header_field_value;
}
break;
case header_field_value:
if (c == '\n')
self->state = error;
else if (c == '\r')
{
value_length = i - value_begin;
field_name = (char *)zmalloc(sizeof(char) * (name_length + 1));
field_value = (char *)zmalloc(sizeof(char) * (value_length + 1));
strncpy(field_name, request + name_begin, name_length);
strncpy(field_value, request + value_begin, value_length);
field_name[name_length] = '\0';
field_value[value_length] = '\0';
for (size_t j = 0; j < name_length; j++)
{
field_name[j] = tolower(field_name[j]);
}
zhash_insert(self->header_fields, field_name, field_value);
zhash_freefn(self->header_fields, field_name, &s_free_item);
free(field_name);
self->state = header_field_cr;
}
else
self->state = header_field_value;
break;
case header_field_cr:
if (c == '\n')
self->state = header_field_begin_name;
else
self->state = error;
break;
case end_line_cr:
if (c == '\n')
{
self->state = complete;
free(request);
return zwshandshake_validate(self);
}
break;
case error:
free(request);
return false;
default:
assert(false);
free(request);
return false;
}
}
free(request);
return false;
}
static void
s_broker_client_msg (broker_t *self, zframe_t *sender, zmsg_t *msg)
{
assert (zmsg_size (msg) >= 2); // Service name + body
zframe_t *service_frame = zmsg_pop (msg);
service_t *service = s_service_require (self, service_frame);
// If we got a MMI service request, process that internally
if (zframe_size (service_frame) >= 4
&& memcmp (zframe_data (service_frame), "mmi.", 4) == 0) {
char *return_code;
if (zframe_streq (service_frame, "mmi.service")) {
char *name = zframe_strdup (zmsg_last (msg));
service_t *service =
(service_t *) zhash_lookup (self->services, name);
return_code = service && service->workers? "200": "404";
free (name);
}
else
// The filter service that can be used to manipulate
// the command filter table.
if (zframe_streq (service_frame, "mmi.filter")
&& zmsg_size (msg) == 3) {
zframe_t *operation = zmsg_pop (msg);
zframe_t *service_frame = zmsg_pop (msg);
zframe_t *command_frame = zmsg_pop (msg);
char *command_str = zframe_strdup (command_frame);
if (zframe_streq (operation, "enable")) {
service_t *service = s_service_require (self, service_frame);
s_service_enable_command (service, command_str);
return_code = "200";
}
else
if (zframe_streq (operation, "disable")) {
service_t *service = s_service_require (self, service_frame);
s_service_disable_command (service, command_str);
return_code = "200";
}
else
return_code = "400";
zframe_destroy (&operation);
zframe_destroy (&service_frame);
zframe_destroy (&command_frame);
free (command_str);
// Add an empty frame; it will be replaced by the return code.
zmsg_pushstr (msg, "");
}
else
return_code = "501";
zframe_reset (zmsg_last (msg), return_code, strlen (return_code));
// Insert the protocol header and service name, then rewrap envelope.
zmsg_push (msg, zframe_dup (service_frame));
zmsg_pushstr (msg, MDPC_REPORT);
zmsg_pushstr (msg, MDPC_CLIENT);
zmsg_wrap (msg, zframe_dup (sender));
zmsg_send (&msg, self->socket);
}
else {
int enabled = 1;
if (zmsg_size (msg) >= 1) {
zframe_t *cmd_frame = zmsg_first (msg);
char *cmd = zframe_strdup (cmd_frame);
enabled = s_service_is_command_enabled (service, cmd);
free (cmd);
}
// Forward the message to the worker.
if (enabled) {
zmsg_wrap (msg, zframe_dup (sender));
zlist_append (service->requests, msg);
s_service_dispatch (service);
}
// Send a NAK message back to the client.
else {
zmsg_push (msg, zframe_dup (service_frame));
zmsg_pushstr (msg, MDPC_NAK);
zmsg_pushstr (msg, MDPC_CLIENT);
zmsg_wrap (msg, zframe_dup (sender));
zmsg_send (&msg, self->socket);
}
}
zframe_destroy (&service_frame);
}
static rsRetVal rcvData(){
DEFiRet;
if(!listenerList) {
listenerList = zlist_new();
if(!listenerList) {
errmsg.LogError(0, NO_ERRCODE, "could not allocate list");
ABORT_FINALIZE(RS_RET_ERR);
}
}
zactor_t *authActor;
zcert_t *serverCert;
if(runModConf->authenticator == 1) {
authActor = zactor_new(zauth, NULL);
zstr_sendx(authActor, "CURVE", runModConf->clientCertPath, NULL);
zsock_wait(authActor);
}
instanceConf_t *inst;
for(inst = runModConf->root; inst != NULL; inst=inst->next) {
CHKiRet(addListener(inst));
}
zpoller_t *poller = zpoller_new(NULL);
if(!poller) {
errmsg.LogError(0, NO_ERRCODE, "could not create poller");
ABORT_FINALIZE(RS_RET_ERR);
}
DBGPRINTF("imczmq: created poller\n");
struct listener_t *pData;
pData = zlist_first(listenerList);
if(!pData) {
errmsg.LogError(0, NO_ERRCODE, "imczmq: no listeners were "
"started, input not activated.\n");
ABORT_FINALIZE(RS_RET_NO_RUN);
}
while(pData) {
int rc = zpoller_add(poller, pData->sock);
if(rc != 0) {
errmsg.LogError(0, NO_ERRCODE, "imczmq: could not add "
"socket to poller, input not activated.\n");
ABORT_FINALIZE(RS_RET_NO_RUN);
}
pData = zlist_next(listenerList);
}
zframe_t *frame;
zsock_t *which = (zsock_t *)zpoller_wait(poller, -1);
while(which) {
if (zpoller_terminated(poller)) {
break;
}
pData = zlist_first(listenerList);
while(pData->sock != which) {
pData = zlist_next(listenerList);
}
if(which == pData->sock) {
DBGPRINTF("imczmq: found matching socket\n");
}
frame = zframe_recv(which);
char *buf = zframe_strdup(frame);
if(buf == NULL) {
DBGPRINTF("imczmq: null buffer\n");
continue;
}
smsg_t *pMsg;
if(msgConstruct(&pMsg) == RS_RET_OK) {
MsgSetRawMsg(pMsg, buf, strlen(buf));
MsgSetInputName(pMsg, s_namep);
MsgSetHOSTNAME(pMsg, glbl.GetLocalHostName(), ustrlen(glbl.GetLocalHostName()));
MsgSetRcvFrom(pMsg, glbl.GetLocalHostNameProp());
MsgSetRcvFromIP(pMsg, glbl.GetLocalHostIP());
MsgSetMSGoffs(pMsg, 0);
MsgSetFlowControlType(pMsg, eFLOWCTL_NO_DELAY);
MsgSetRuleset(pMsg, pData->ruleset);
pMsg->msgFlags = NEEDS_PARSING | PARSE_HOSTNAME;
submitMsg2(pMsg);
}
free(buf);
which = (zsock_t *)zpoller_wait(poller, -1);
}
finalize_it:
zframe_destroy(&frame);
zpoller_destroy(&poller);
pData = zlist_first(listenerList);
while(pData) {
zsock_destroy(&pData->sock);
free(pData->ruleset);
pData = zlist_next(listenerList);
}
zlist_destroy(&listenerList);
zactor_destroy(&authActor);
zcert_destroy(&serverCert);
RETiRet;
}
