int zmq::socket_base_t::monitor (const char *addr_, int events_) { if (unlikely (ctx_terminated)) { errno = ETERM; return -1; } // Support deregistering monitoring endpoints as well if (addr_ == NULL) { stop_monitor (); return 0; } // Parse addr_ string. std::string protocol; std::string address; if (parse_uri (addr_, protocol, address) || check_protocol (protocol)) return -1; // Event notification only supported over inproc:// if (protocol != "inproc") { errno = EPROTONOSUPPORT; return -1; } // Register events to monitor monitor_events = events_; monitor_socket = zmq_socket (get_ctx (), ZMQ_PAIR); if (monitor_socket == NULL) return -1; // Never block context termination on pending event messages int linger = 0; int rc = zmq_setsockopt (monitor_socket, ZMQ_LINGER, &linger, sizeof (linger)); if (rc == -1) stop_monitor (); // Spawn the monitor socket endpoint rc = zmq_bind (monitor_socket, addr_); if (rc == -1) stop_monitor (); return rc; }
int main(int argc, char *argv []) { void *context, *socket; char *topic, *string; int64_t more; if (argc < 2) { fprintf(stderr, "USAGE: zmq_echo <address> [topic]\n"); return 1; } context = zmq_init(1); printf("connecting to %s...\n", argv[1]); socket = zmq_socket(context, ZMQ_SUB); zmq_connect(socket, argv[1]); if (argc > 2) { topic = argv[2]; printf("subscribing to \"%s\" topic...\n", topic); } else { topic = ""; printf("subscribing to all topics...\n"); } zmq_setsockopt(socket, ZMQ_SUBSCRIBE, topic, strlen(topic)); printf(">> "); fflush(stdout); while (1) { string = zmq_recv_string(socket, &more); printf(more ? "%s" : "%s\n>> ", string); fflush(stdout); free(string); } zmq_close(socket); zmq_term(context); return 0; }
void throttleObject::sendLoginRegisterToThrottle(const string& ip,unsigned short manager_port) { if(!m_connectorLoginToThro) { managerProPackage::send(m_sendLHRToThrottleHandler, managerProtocol_messageTrans_CONNECTOR , managerProtocol_messageType_LOGIN_REQ, ip, manager_port); g_manager_logger->info("[login req][connector -> throttle]:{0},{1:d}", m_throttle_ip, m_throttle_managerPort); return; } for(auto it = m_throSubKey_list.begin(); it != m_throSubKey_list.end(); it++) { throSubKeyObject* subKeyObject = *it; if(subKeyObject == NULL) continue; string& key = subKeyObject->get_throSubKey(); if(key.empty()) continue; if(subKeyObject->get_throSubscribed() == false) { //if don't setsockopt with ZMQ_SUBSCRIBE option,this zmq_socket will recv nothing !!! for(auto it=m_recvAdReqVector.begin(); it != m_recvAdReqVector.end(); it++) { recvAdReq_t *obj = *it; int rc = zmq_setsockopt(obj->m_recvAdReqFromThrottleHandler,ZMQ_SUBSCRIBE,key.c_str(),key.size()); if(rc == 0) { subKeyObject->set_throSubscribed(true); g_manager_logger->info("[add ZMQ_SUBSCRIBE]: {0}",key); cout << "[add ZMQ_SUBSCRIBE]: " << key << endl; } } } if(subKeyObject->get_throRegisted() == false) { managerProPackage::send(m_sendLHRToThrottleHandler, managerProtocol_messageTrans_CONNECTOR , managerProtocol_messageType_REGISTER_REQ, key, ip, manager_port); g_manager_logger->info("[register req][connector -> throttle]:{0},{1:d}", m_throttle_ip, m_throttle_managerPort); cout << "[register req][connector -> throttle]!" << endl; } } }
int main(void) { // connect to task ventilator void *context = zmq_ctx_new(); 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, "", 0); // Process messages from both sockets while (1) { char msg[256]; zmq_pollitem_t items[] = { { receiver, 0, ZMQ_POLLIN, 0 }, { subscriber, 0, ZMQ_POLLIN, 0 }, }; zmq_poll(items, 2, -1); if (items[0].revents & ZMQ_POLLIN) { int size = zmq_recv(receiver, msg, 255, 0); if (size != -1) { break; } } if (items[1].revents & ZMQ_POLLIN) { //int size = zmq_recv(subscriber, msg, 255, 0); char *msg = s_recv(subscriber); if (msg != NULL) { // process weather update puts(msg); free(msg); } } } zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
int main(void) { void *context = zmq_ctx_new(); void *receiver = zmq_socket(context, ZMQ_PULL); zmq_connect(receiver, "tcp://localhost:5557"); void *subscriber = zmq_socket(context, ZMQ_SUB); zmq_connect(subscriber, "tcp://localhost:5556"); zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, "10001 ", 6); zmq_pollitem_t items[] = { {receiver, 0, ZMQ_POLLIN, 0}, {subscriber, 0, ZMQ_POLLIN, 0}, }; while(1) { 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); printf("receiver: %s\n", (char *)zmq_msg_data(&message)); zmq_msg_close(&message); } if (items[1].revents & ZMQ_POLLIN) { zmq_msg_init(&message); zmq_msg_recv(&message, subscriber, 0); printf("subscribe: %s\n", (char *)zmq_msg_data(&message)); zmq_msg_close(&message); } } zmq_close(receiver); zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
int main(){ void *context=zmq_ctx_new(); void *sink=zmq_socket(context, ZMQ_ROUTER); zmq_bind(sink, "inproc://example"); void *anonymous=zmq_socket(context, ZMQ_REQ); zmq_connect(anonymous, "inproc://example"); s_send(anonymous, "ROUTER uses a generated UUID", 0, NULL); s_dump(sink); void *identified=zmq_socket(context, ZMQ_REQ); zmq_setsockopt(identified, ZMQ_IDENTITY, "PEER2", 5); zmq_connect(identified, "inproc://example"); s_send(identified, "ROUTER socker uses REQ's socker identity", 0, NULL); s_dump(sink); zmq_close(identified); zmq_close(anonymous); zmq_close(sink); zmq_ctx_destroy(context); return 0; }
void pre_allocate_sock (void *zmq_socket, const char *path) { struct sockaddr_un addr; addr.sun_family = AF_UNIX; strcpy (addr.sun_path, path); unlink (path); int s_pre = socket (AF_UNIX, SOCK_STREAM, 0); assert (s_pre != -1); int rc = bind (s_pre, (struct sockaddr *) &addr, sizeof (struct sockaddr_un)); assert (rc == 0); rc = listen (s_pre, SOMAXCONN); assert (rc == 0); rc = zmq_setsockopt (zmq_socket, ZMQ_USE_FD, &s_pre, sizeof (s_pre)); assert(rc == 0); }
/** * Called by Java's Socket::setBytesSockopt(int option, byte[] value). */ JNIEXPORT void JNICALL Java_org_zeromq_ZMQ_00024Socket_setBytesSockopt (JNIEnv *env, jobject obj, jint option, jbyteArray value) { switch (option) { #if (ZMQ_VERSION_MAJOR <= 3) case ZMQ_IDENTITY: #endif case ZMQ_SUBSCRIBE: case ZMQ_UNSUBSCRIBE: { if (value == NULL) { raise_exception (env, EINVAL); return; } void *s = get_socket (env, obj, 1); jbyte *optval = env->GetByteArrayElements (value, NULL); if (! optval) { raise_exception (env, EINVAL); return; } size_t optvallen = env->GetArrayLength (value); int rc = zmq_setsockopt (s, option, optval, optvallen); int err = zmq_errno(); env->ReleaseByteArrayElements (value, optval, 0); if (rc != 0) { raise_exception (env, err); } return; } default: raise_exception (env, EINVAL); return; } }
int main(void) { struct heartbeat_socket_info * receiver; struct heartbeat_socket_info * subscriber; receiver = heartbeat_connect_socket(ZMQ_PULL, "tcp://localhost:5557"); subscriber = heartbeat_connect_socket(ZMQ_SUB, "tcp://localhost:5556"); zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, "10001", 6); char *string1; char *string2; while (1) { char msg[256]; zmq_pollitem_t items[] = { { receiver, 0, ZMQ_POLLIN, 0}, { subscriber, 0, ZMQ_POLLIN, 0} }; zmq_poll(items, 2, -1); if (items[0].revents & ZMQ_POLLIN) { string1 = heartbeat_recv_msg(receiver, 0); if (strlen(string1) != -1) { } free(string1); } if (items[1].revents & ZMQ_POLLIN) { string2 = heartbeat_recv_msg(subscriber, 0); if (strlen(string2) != -1) { } free(string2); } } heartbeat_disconnect_socket(subscriber); heartbeat_disconnect_socket(receiver); return 0; }
void Chat::init(const std::string& my_id) { std::string bind_ep; listening_port_ = create_port(my_id); bind_ep = std::string("tcp://*:") + boost::lexical_cast<std::string>(listening_port_); zmq_ctx_ = g_zmq_ctx.get_zmq_ctx(); publisher_ = zmq_socket(zmq_ctx_, ZMQ_PUB); zmq_bind(publisher_, bind_ep.c_str()); subscriber_ = zmq_socket(zmq_ctx_, ZMQ_SUB); zmq_setsockopt(subscriber_, ZMQ_SUBSCRIBE, "", 0); gate_ = zmq_socket(zmq_ctx_, ZMQ_PAIR); zmq_bind(gate_, MAGIC_GATE); std::string test_msg("hello from "); test_msg += my_id; zmq_send(publisher_, test_msg.c_str(), test_msg.length(), 0); }
//******************************************************************************** // Function: redirect_count // // Description: Recieve Control Plane redirect count. //******************************************************************************** static int32_t redirect_count(void) { void *context = zmq_ctx_new (); void *requester = zmq_socket(context, ZMQ_REQ); int32_t timeo{}; zmq_setsockopt(requester, ZMQ_LINGER, (void*) &timeo, sizeof(timeo)); char buffer[64]; sprintf(buffer, "tcp://localhost:%d", TCPLANE_SERVICE); zmq_connect(requester, buffer); sprintf(buffer, "%d", redirectCount); zmq_send(requester, buffer, strlen(buffer), 0); size_t size = timed_read(requester, buffer, sizeof(buffer), READ_TIMEOUT); if(size) size = atoi(buffer); zmq_close(requester); zmq_ctx_destroy(context); return size; }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); // Spawn ZAP handler void *zap_thread = zmq_threadstart (&zap_handler, ctx); // Server socket will accept connections void *server = zmq_socket (ctx, ZMQ_DEALER); assert (server); int rc = zmq_setsockopt (server, ZMQ_IDENTITY, "IDENT", 6); assert (rc == 0); rc = zmq_bind (server, "tcp://*:9999"); assert (rc == 0); // Client socket that will try to connect to server void *client = zmq_socket (ctx, ZMQ_DEALER); assert (client); rc = zmq_connect (client, "tcp://localhost:9999"); assert (rc == 0); bounce (server, client); rc = zmq_close (client); assert (rc == 0); rc = zmq_close (server); assert (rc == 0); // Shutdown rc = zmq_ctx_term (ctx); assert (rc == 0); // Wait until ZAP handler terminates. zmq_threadclose (zap_thread); return 0; }
bool SubscriberZMQ::_onInit(TUInt port) { m_context = zmq_ctx_new(); if (m_context == 0) { zmqlog("Error occurred during zmq_ctx_new()"); return false; } m_socket = zmq_socket(m_context, ZMQ_SUB); if (m_socket == 0) { zmqlog("Error occurred during zmq_socket()"); clear(); return false; } TChar address[100] = {'\0'}; sprintf(address, "tcp://localhost:%u", port); int result = zmq_connect(m_socket, address); if (result != 0) { zmqlog("Error occurred during zmq_init()"); clear(); return false; } const TString& subscribeId = getSubscribeId(); result = zmq_setsockopt (m_socket, ZMQ_SUBSCRIBE, subscribeId.c_str(), subscribeId.length() - 1); if (result != 0) { zmqlog("Error occurred during zmq_setsockopt"); clear(); return false; } return true; }
int main (int argc, char const *argv[]) { void* context = zmq_ctx_new(); //create a SUB socket void* subscriber = zmq_socket(context, ZMQ_SUB); const char* filter; if(argc > 1) { filter = argv[1]; } else { filter = "Company1|"; } printf("Collecting stock information from the server.\n"); int conn = zmq_connect(subscriber, "tcp://localhost:4040"); // must set a subscription for SUB socket conn = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter)); int i = 0; for(i = 0; i < 10; i++) { zmq_msg_t reply; zmq_msg_init(&reply); // receive the message, previous message is deallocated zmq_msg_recv(&reply, subscriber, 0); int length = zmq_msg_size(&reply); char* value = malloc(length + 1); memcpy(value, zmq_msg_data(&reply), length); zmq_msg_close(&reply); printf("%s\n", value); free(value); } zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
static int luazmq_skt_set_str_arr (lua_State *L, int option_name) { zsocket *skt; size_t len, tlen, i; const char *option_value; int ret; if(!lua_istable(L, 2)) return luazmq_skt_set_str(L, option_name); skt = luazmq_getsocket(L); tlen = lua_objlen(L,2); for (i = 1; i <= tlen; i++){ lua_rawgeti(L, 2, i); option_value = luaL_checklstring(L, -1, &len); ret = zmq_setsockopt(skt->skt, option_name, option_value, len); if (ret == -1){ int n = luazmq_fail(L, skt); lua_pushnumber(L, i); return n + 1; } } return luazmq_pass(L); }
// We will do this all in one thread to emphasize the sequence // of events... int main (void) { void *context = zmq_init (1); void *client = zmq_socket (context, ZMQ_ROUTER); zmq_bind (client, "ipc://routing.ipc"); void *worker = zmq_socket (context, ZMQ_REP); zmq_setsockopt (worker, ZMQ_IDENTITY, "A", 1); zmq_connect (worker, "ipc://routing.ipc"); // Wait for the worker to connect so that when we send a message // with routing envelope, it will actually match the worker... sleep (1); // Send papa address, address stack, empty part, and request s_sendmore (client, "A"); s_sendmore (client, "address 3"); s_sendmore (client, "address 2"); s_sendmore (client, "address 1"); s_sendmore (client, ""); s_send (client, "This is the workload"); // Worker should get just the workload printf("begine dump worker\n"); s_dump (worker); // We don't play with envelopes in the worker s_send (worker, "This is the reply"); // Now dump what we got off the ROUTER socket... printf("begine dump client\n"); s_dump (client); zmq_close (client); zmq_close (worker); zmq_term (context); return 0; }
int main (void) { void *context = zmq_init (1); // This is where the weather server sits void *frontend = zmq_socket (context, ZMQ_XSUB); zmq_connect (frontend, "tcp://192.168.55.210:5556"); // This is our public endpoint for subscribers void *backend = zmq_socket (context, ZMQ_XPUB); zmq_bind (backend, "tcp://10.1.1.0:8100"); // Subscribe on everything zmq_setsockopt (frontend, ZMQ_SUBSCRIBE, "", 0); // Shunt messages out to our own subscribers while (1) { while (1) { zmq_msg_t message; int64_t more; // Process all parts of the message zmq_msg_init (&message); zmq_recv (frontend, &message, 0); size_t more_size = sizeof (more); zmq_getsockopt (frontend, ZMQ_RCVMORE, &more, &more_size); zmq_send (backend, &message, more? ZMQ_SNDMORE: 0); zmq_msg_close (&message); if (!more) break; // Last message part } } // We don't actually get here but if we did, we'd shut down neatly zmq_close (frontend); zmq_close (backend); zmq_term (context); return 0; }
int main (int argc, char *argv []) { fprintf (stderr, "test_router_behavior running...\n"); void *ctx = zmq_init (1); assert (ctx); // Creating the first socket. void *sa = zmq_socket (ctx, ZMQ_ROUTER); assert (sa); int rc = zmq_bind (sa, "tcp://127.0.0.1:15560"); assert (rc == 0); // Sending a message to an unknown peer with the default behavior. rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE); assert (rc == 7); rc = zmq_send (sa, "DATA", 4, 0); assert (rc == 4); int behavior = 1; // Setting the socket behavior to a new mode. rc = zmq_setsockopt (sa, ZMQ_ROUTER_BEHAVIOR, &behavior, sizeof (behavior)); assert (rc == 0); // Sending a message to an unknown peer with verbose behavior. rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE | ZMQ_DONTWAIT); assert (rc == -1 && errno == EAGAIN); rc = zmq_close (sa); assert (rc == 0); rc = zmq_term (ctx); assert (rc == 0); return 0 ; }
/** * Called by Java's Socket::setStringSockopt(int option, String optval). */ JNIEXPORT void JNICALL Java_org_zeromq_ZMQ_00024Socket_setStringSockopt (JNIEnv *env, jobject obj, jint option, jstring optval) { switch (option) { case ZMQ_IDENTITY: case ZMQ_SUBSCRIBE: case ZMQ_UNSUBSCRIBE: { if (optval == NULL) { raise_exception (env, EINVAL); return; } void *s = get_socket (env, obj, 1); const char *value = env->GetStringUTFChars (optval, NULL); if (! value) { raise_exception (env, EINVAL); return; } int rc = zmq_setsockopt (s, option, value, strlen (value)); int err = errno; env->ReleaseStringUTFChars (optval, value); if (rc != 0) { raise_exception (env, err); return; } return; } default: raise_exception (env, EINVAL); return; } }
int _tmain(int argc, _TCHAR* argv[]) { setlocale(LC_ALL,"Chinese"); setlocale(LC_ALL,"chs"); void *m_context; void *m_subscriber; char m_subAddr[64]; m_context = zmq_init(1); m_subscriber = zmq_socket(m_context,ZMQ_SUB); char *puberIp = "127.0.0.1"; WORD port = 8585; memset(m_subAddr,0,sizeof(m_subAddr)); sprintf_s(m_subAddr,"tcp://%s:%d",puberIp,port); zmq_connect(m_subscriber,m_subAddr); char *option = "642"; int ret = zmq_setsockopt(m_subscriber,ZMQ_SUBSCRIBE,"642",strlen(option)); while (1) { BYTE buffer[1024] = {0}; DWORD bufLen = sizeof(buffer); DWORD gotLen = zmq_recv(m_subscriber,buffer,bufLen,0); printf("收到发布信息:%s\n",buffer); } zmq_close(m_subscriber); zmq_term(m_context); return 0; }
static void subscriber_thread_main (void *pvoid) { const proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid; const int idx = cfg->thread_idx; void *subsocket = zmq_socket (cfg->context, ZMQ_SUB); assert (subsocket); set_hwm (subsocket); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (subsocket, ZMQ_SUBSCRIBE, 0, 0)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_connect (subsocket, cfg->backend_endpoint[idx])); // Receive message_count messages uint64_t rxsuccess = 0; bool success = true; while (success) { zmq_msg_t msg; int rc = zmq_msg_init (&msg); assert (rc == 0); rc = zmq_msg_recv (&msg, subsocket, 0); if (rc != -1) { TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg)); rxsuccess++; } if (rxsuccess == message_count) break; } // Cleanup zmq_close (subsocket); printf ("subscriber thread ended\n"); }
int main (void) { fprintf (stderr, "test_router_mandatory_tipc running...\n"); void *ctx = zmq_init (1); assert (ctx); // Creating the first socket. void *sa = zmq_socket (ctx, ZMQ_ROUTER); assert (sa); int rc = zmq_bind (sa, "tipc://{15560,0,0}"); assert (rc == 0); // Sending a message to an unknown peer with the default setting rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE); assert (rc == 7); rc = zmq_send (sa, "DATA", 4, 0); assert (rc == 4); int mandatory = 1; // Set mandatory routing on socket rc = zmq_setsockopt (sa, ZMQ_ROUTER_MANDATORY, &mandatory, sizeof (mandatory)); assert (rc == 0); // Send a message and check that it fails rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE | ZMQ_DONTWAIT); assert (rc == -1 && errno == EHOSTUNREACH); rc = zmq_close (sa); assert (rc == 0); rc = zmq_term (ctx); assert (rc == 0); return 0 ; }
int main(void) { // Prepare our context and subscriber void *context = zmq_ctx_new(); void *subscriber = zmq_socket(context, ZMQ_SUB); zmq_connect(subscriber, "tcp://localhost:5563"); zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, "B", 1); while (1) { // Read envelope with address char *address = s_recv(subscriber); // Read messages contents char *contents = s_recv(subscriber); printf("[%s] %s\n", address, contents); free(address); free(contents); } // We never get here, but clean up anyhow zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
int main (void) { // Create the infrastructure void *ctx = zmq_ctx_new (); assert (ctx); void *sb = zmq_socket (ctx, ZMQ_ROUTER); assert (sb); int val = 0; int rc = zmq_setsockopt (sb, ZMQ_LINGER, &val, sizeof (val)); assert (rc == 0); do_bind_and_verify (sb, "tcp://127.0.0.1:5560"); do_bind_and_verify (sb, "tcp://127.0.0.1:5561"); rc = zmq_close (sb); assert (rc == 0); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0 ; }
int main() { void* context = zmq_ctx_new(); void* sink = zmq_socket(context, ZMQ_ROUTER); zmq_bind(sink, "inproc://identity-example"); // First allow 0MQ to set the identity void* anonymous = zmq_socket(context, ZMQ_REQ); zmq_connect(anonymous, "inproc://identity-example"); s_send(anonymous, "ROUTER uses a generated UUID"); s_dump(sink); // Then set the identity ourselves void* identified = zmq_socket(context, ZMQ_REQ); zmq_setsockopt(identified, ZMQ_IDENTITY, "PEER2", 5); zmq_connect(identified, "inproc://identity-example"); s_send(identified, "ROUTER socket uses REQ's socket identity"); s_dump(sink); zmq_close(sink); zmq_close(anonymous); zmq_close(identified); zmq_ctx_destroy(context); return 0; }
int main (int argc, char *argv []) { // Socket to talk to server printf ("Collecting updates from chat server…\n"); void *context = zmq_ctx_new (); void *subscriber = zmq_socket (context, ZMQ_SUB); int rc = zmq_connect (subscriber, "tcp://localhost:5556"); assert (rc == 0); char *filter = (argc > 1)? argv [1]: ">"; rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, filter, strlen (filter)); assert (rc == 0); for (;;) { char *string = s_recv (subscriber); printf("Received: %s\n", string); free(string); } zmq_close (subscriber); zmq_ctx_destroy (context); return 0; }
int main(void) { void *context = zmq_ctx_new(); // set up sender to send messages to the sb void *sender = zmq_socket(context, ZMQ_PUSH); zmq_connect(sender, "ipc:///tmp/zero_sb_in"); printf("PO: Connected to SB to send messages\n"); // set up subscriber to get new messages from subscribed MIDs void *subscriber = zmq_socket(context, ZMQ_SUB); int rc = zmq_connect(subscriber, "ipc:///tmp/zero_sb_pub"); assert(rc == 0); printf("PO: Connected to SB to receive messages\n"); char *filter = "10"; rc = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter)); assert(rc == 0); printf("PO: \tAnd the filter is in place.\n"); // Wait for a ping char buffer[256]; rc = zmq_recv(subscriber, buffer, 256, 0); if (rc > 255) { printf("PO: I can't handle this\n"); } else { buffer[rc] = '\0'; printf("PO: Received: %s\n", buffer); } // Respond with a pong zmq_send(sender, "11 pong", 7, 0); zmq_close(sender); zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
int main(int argc, char *argv[]) { // Socket to talk to server printf("Collecting updates from weather server...\n"); void *context = zmq_ctx_new(); void *subscriber = zmq_socket(context, ZMQ_SUB); int rc = zmq_connect(subscriber, "tcp://localhost:5556"); assert(rc == 0); // Subscriber to zipcode, default is NYC, 10001 char *filter = (argc > 1)? argv[1] : "10001 "; rc = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter)); assert(rc == 0); // Process 100 updates int update_nbr; long total_temp = 0; for(update_nbr=0; update_nbr < 100;update_nbr++) { char *string = s_recv(subscriber); int zipcode, temperature, relhumidity; sscanf(string, "%d %d %d", &zipcode, &temperature, &relhumidity); printf("%03d ", update_nbr); printf(string); printf(" %d\n"); total_temp += temperature; free(string); } printf("Average temperature for zipcode '%s' was %dF\n", filter, (int)(total_temp/update_nbr)); zmq_close(subscriber); zmq_ctx_destroy(context); return 0; }
// We have two workers, here we copy the code, normally these would // run on different boxes... // static void * worker_task_a (void *args) { void *context = zmq_init (1); void *worker = zmq_socket (context, ZMQ_DEALER); zmq_setsockopt (worker, ZMQ_IDENTITY, "A", 1); zmq_connect (worker, "ipc://routing.ipc"); int total = 0; while (1) { // We receive one part, with the workload char *request = s_recv (worker); int finished = (strcmp (request, "END") == 0); free (request); if (finished) { printf ("A received: %d\n", total); break; } total++; } zmq_close (worker); zmq_term (context); return NULL; }
int Log_init(bstring access_log, bstring log_spec) { int rc = 0; LogConfig *config = NULL; if(LOG_SOCKET == NULL) { check(ZMQ_CTX, "No ZMQ context, cannot start access log."); if(Setting_get_int("disable.access_logging", 0)) { log_info("Access log is disabled according to disable.access_logging."); } else { config = LogConfig_create(access_log, log_spec); check(config, "Failed to configure access logging."); LOG_SOCKET = zmq_socket(ZMQ_CTX, ZMQ_PUB); check(LOG_SOCKET != NULL, "Failed to create access log socket"); #ifdef ZMQ_LINGER int opt = 0; rc = zmq_setsockopt(LOG_SOCKET, ZMQ_LINGER, &opt, sizeof(opt)); check(rc == 0, "Could not set the linger option."); #endif rc = zmq_bind(LOG_SOCKET, bdata(log_spec)); check(rc == 0, "Failed to bind access_log zeromq socket."); pthread_create(&LOG_THREAD, NULL, Log_internal_thread, config); } } return 0; error: LogConfig_destroy(config); return -1; }