Example #1
1
int test_blocking (int send_hwm_, int msg_cnt_)
{
    // Set up bind socket
    void *pub_socket = test_context_socket (ZMQ_PUB);
    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (pub_socket, "inproc://a"));

    // Set up connect socket
    void *sub_socket = test_context_socket (ZMQ_SUB);
    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub_socket, "inproc://a"));

    //set a hwm on publisher
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (pub_socket, ZMQ_SNDHWM, &send_hwm_, sizeof (send_hwm_)));
    int wait = 1;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (pub_socket, ZMQ_XPUB_NODROP, &wait, sizeof (wait)));
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (sub_socket, ZMQ_SUBSCRIBE, 0, 0));

    // Send until we block
    int send_count = 0;
    int recv_count = 0;
    while (send_count < msg_cnt_) {
        const int rc = zmq_send (pub_socket, NULL, 0, ZMQ_DONTWAIT);
        if (rc == 0) {
            ++send_count;
        } else if (-1 == rc) {
            TEST_ASSERT_EQUAL_INT (EAGAIN, errno);
            recv_count += receive (sub_socket);
            TEST_ASSERT_EQUAL_INT (send_count, recv_count);
        }
    }

    recv_count += receive (sub_socket);

    // Clean up
    test_context_socket_close (sub_socket);
    test_context_socket_close (pub_socket);

    return recv_count;
}
int main (int argc, char *argv[])
{
    zmq::context_t context(1);

    //  Socket facing clients
    zmq::socket_t frontend (context, ZMQ_ROUTER);
    frontend.bind("tcp://*:5559");

    //  Socket facing services
    zmq::socket_t backend (context, ZMQ_DEALER);
    zmq_bind (static_cast<void *>(backend), "tcp://*:5560");

    //  Start built-in device
    zmq_device (
            ZMQ_QUEUE,
            static_cast<void *>(frontend),
            static_cast<void *>(backend)
            );
    return 0;
}
Example #3
0
static void
agent_control_message (agent_t *self)
{
    zmsg_t *msg = zmsg_recv (self->pipe);
    char *method = zmsg_popstr (msg);
    if (streq (method, "BIND")) {
        char *endpoint = zmsg_popstr (msg);
        assert (endpoint);
        int rc = zmq_bind (self->router, endpoint);
        assert (rc == 0);
        free (endpoint);
    }
    else
    if (streq (method, "STOP")) {
        zstr_send (self->pipe, "OK");
        self->stopped = true;
    }
    free (method);
    zmsg_destroy (&msg);
}
Example #4
0
int main ()
{
    void *ctx = zmq_init (1);
    assert (ctx);
    
    void *pub = zmq_socket (ctx, ZMQ_PUB);
    assert (pub);
    int rc = zmq_bind (pub, "tcp://*:2211");
    assert (rc == 0);
    
    void *sub = zmq_socket (ctx, ZMQ_SUB);
    assert (sub);

    uint64_t size = 1;
    rc = zmq_setsockopt (sub, ZMQ_HWM, &size, sizeof (size));
    assert (rc == 0);
    
    int64_t swap = 10000000;
    rc = zmq_setsockopt (sub, ZMQ_SWAP, &swap, sizeof (swap));
    assert (rc == 0);
    
    rc = zmq_setsockopt (sub, ZMQ_SUBSCRIBE, "", 0);
    assert (rc == 0);
    rc = zmq_connect (sub, "tcp://127.0.0.1:2211");
    assert (rc == 0);

    int count;
    for (count = 0; count < 100000; count++) {
        zmq_msg_t msg;
        zmq_msg_init_size (&msg, 0);
        zmq_send (pub, &msg, 0);
        zmq_msg_close (&msg);
    }
    int linger = 0;
    zmq_setsockopt (pub, ZMQ_LINGER, &linger, sizeof (int));
    zmq_setsockopt (sub, ZMQ_LINGER, &linger, sizeof (int));
    zmq_close (pub);
    zmq_close (sub);
    zmq_term (ctx);
    return 0;
}
Example #5
0
int main (void)
{
  void *context = zmq_ctx_new ();

  // Socket to send messages on
  void *sender = zmq_socket (context, ZMQ_PUSH);
  zmq_bind (sender, "tcp://*:5557");

  // Socket to send start of batch message on
  void *sink = zmq_socket (context, ZMQ_PUSH);
  zmq_connect (sink, "tcp://localhost:5558");

  printf ("Press Enter when the workers are ready: ");
  getchar ();
  printf ("Sending tasks to workers…\n");

  // The first message is "0" and signals start of batch
  s_send (sink, "0");

  // Initialize random number generator
  srandom ((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 = randof (100) + 1;
    total_msec += workload;
    char string [10];
    sprintf (string, "%d", workload);
    s_send (sender, string);
  }
  printf ("Total expected cost: %d msec\n", total_msec);

  zmq_close (sink);
  zmq_close (sender);
  zmq_ctx_destroy (context);
  return 0;
}
Example #6
0
int main(int argc, const char * argv[]) {

    char time_buf[TIMESIZE], message[MSGSIZE];
    void *ctx = NULL, *publisher = NULL;
    int retval = 0, nbytes = 0, lucky_number = 0;
    time_t current_time;
    
    ctx = zmq_ctx_new();
    
    publisher = zmq_socket(ctx, ZMQ_PUB);
    
    retval = zmq_bind(publisher, "tcp://*:9000");    
    if (retval != 0) {
        fprintf(stderr, "Unable to bind zmq socket on port 9000\n");
        exit(1);
    }
    
    srandom(42);
    while(1) {
        current_time = time(NULL);
        ctime_r(&current_time, time_buf);

        // Remove the newline added by ctime_r
        time_buf[24] = '\0';
        
        lucky_number = (int) (rand() % 1000000L);
        
        sprintf(message, "%s %06d", time_buf, lucky_number);
        
        nbytes = zmq_send(publisher, message, MSGSIZE, 0);
        if (nbytes != MSGSIZE) {
            fprintf(stderr, "ERROR: Unable to send bytes to subscriber\n");
        }
        
        sleep(1);
    }
    
    zmq_close(publisher);
    zmq_ctx_destroy(ctx);
    return 0;
}
void test_basic ()
{
    size_t len = MAX_SOCKET_STRING;
    char my_endpoint[MAX_SOCKET_STRING];
    void *router = test_context_socket (ZMQ_ROUTER);

    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (router, "tcp://127.0.0.1:*"));
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_getsockopt (router, ZMQ_LAST_ENDPOINT, my_endpoint, &len));

    //  Send a message to an unknown peer with the default setting
    //  This will not report any error
    send_string_expect_success (router, "UNKNOWN", ZMQ_SNDMORE);
    send_string_expect_success (router, "DATA", 0);

    //  Send a message to an unknown peer with mandatory routing
    //  This will fail
    int mandatory = 1;
    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (router, ZMQ_ROUTER_MANDATORY,
                                               &mandatory, sizeof (mandatory)));
    int rc = zmq_send (router, "UNKNOWN", 7, ZMQ_SNDMORE);
    TEST_ASSERT_EQUAL_INT (-1, rc);
    TEST_ASSERT_EQUAL_INT (EHOSTUNREACH, errno);

    //  Create dealer called "X" and connect it to our router
    void *dealer = test_context_socket (ZMQ_DEALER);
    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (dealer, ZMQ_ROUTING_ID, "X", 1));
    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, my_endpoint));

    //  Get message from dealer to know when connection is ready
    send_string_expect_success (dealer, "Hello", 0);
    recv_string_expect_success (router, "X", 0);

    //  Send a message to connected dealer now
    //  It should work
    send_string_expect_success (router, "X", ZMQ_SNDMORE);
    send_string_expect_success (router, "Hello", 0);

    test_context_socket_close (router);
    test_context_socket_close (dealer);
}
Example #8
0
void test_round_robin_out (void *ctx)
{
    void *req = zmq_socket (ctx, ZMQ_REQ);
    assert (req);

    int rc = zmq_bind (req, bind_address);
    assert (rc == 0);

    const size_t services = 5;
    void *rep [services];
    for (size_t peer = 0; peer < services; peer++) {
        rep [peer] = zmq_socket (ctx, ZMQ_REP);
        assert (rep [peer]);

        int timeout = 250;
        rc = zmq_setsockopt (rep [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
        assert (rc == 0);

        rc = zmq_connect (rep [peer], connect_address);
        assert (rc == 0);
    }
    //  We have to give the connects time to finish otherwise the requests 
    //  will not properly round-robin. We could alternatively connect the
    //  REQ sockets to the REP sockets.
    msleep (SETTLE_TIME);
    
    // Send our peer-replies, and expect every REP it used once in order
    for (size_t peer = 0; peer < services; peer++) {
        s_send_seq (req, "ABC", SEQ_END);
        s_recv_seq (rep [peer], "ABC", SEQ_END);
        s_send_seq (rep [peer], "DEF", SEQ_END);
        s_recv_seq (req, "DEF", SEQ_END);
    }

    close_zero_linger (req);
    for (size_t peer = 0; peer < services; peer++)
        close_zero_linger (rep [peer]);

    // Wait for disconnects.
    msleep (SETTLE_TIME);
}
int
main(int argc, char *argv[])
{
	void	*context = NULL;
	void	*sender = NULL;
	FILE	*fp = NULL;
	char	 line[1024];

	if (argc <= 1) {
		printf("provide a file\n");
		return ERROR;
	}

	if (access(argv[1], F_OK) == -1 ) {
		printf("%s file does not exist\n", argv[1]);
		return ERROR;
	}
	fp = fopen(argv[1], "r");
	if (fp == NULL) {
		printf("unable to open %s\n", argv[1]);
		return ERROR;
	}

	context = zmq_ctx_new();
	sender = zmq_socket(context, ZMQ_PUSH);
	set_socket_timeout(sender);
	zmq_bind(sender, VENTBIND);

	while(fgets(line, sizeof(line), fp)) {
		if (line[0] == '#')
			continue;

		if (s_send(sender, line) < 0)
			perror("s_send");
	}

	fclose(fp);
	zmq_close(sender);
	zmq_ctx_destroy(context);
	return OK;
}
Example #10
0
void Van::bind() {
  receiver_ = zmq_socket(context_, ZMQ_ROUTER);
  CHECK(receiver_ != nullptr)
      << "create receiver socket failed : " << zmq_strerror(errno);
  std::string addr = "tcp://*:";
  if (FLAGS_bind_to) {
    LOG(INFO) << "Use port from command line";
    addr += std::to_string(FLAGS_bind_to);
  } else {
    LOG(INFO) << "Use port from node specification";
    CHECK(myNode_.has_port()) << myNode_.ShortDebugString();
    addr += std::to_string(myNode_.port());
  }

  if (FLAGS_local) {
    addr = "ipc:///tmp/" + myNode_.id();
  }
  CHECK(zmq_bind(receiver_, addr.c_str()) == 0)
      << "bind to " << addr << " failed:" << zmq_strerror(errno);
  VLOG(1) << "Bind to " << addr;
}
Example #11
0
static void *step2 (void *context)
{
    // Bind inproc socket before starting step1
    void *receiver = zmq_socket (context, ZMQ_PAIR);
    zmq_bind (receiver, "inproc://step2");
    pthread_t thread;
    pthread_create (&thread, NULL, step1, context);

    // Wait for signal and pass it on
    char *string = s_recv (receiver);
    free (string);
    zmq_close (receiver);

    // Connect to step3 and tel it we're ready
    void *xmitter = zmq_socket (context, ZMQ_PAIR);
    zmq_connect (xmitter, "inproc://step3");
    s_send (xmitter, "READY");
    zmq_close (xmitter);

    return NULL;
}
Example #12
0
int main()
{
    int rc;
    void *ctx, *s;
    zmq_msg_t query, resultset;
    const char *query_string, *resultset_string = "ok";

    ctx = zmq_init(1);
    assert(ctx);

    s = zmq_socket(ctx, ZMQ_REP);
    assert(s);

    rc = zmq_bind(s, "tcp://127.0.0.1:5555");
    assert(rc == 0);

    while (1)
    {
        rc = zmq_msg_init(&query);
        assert(rc == 0);

        rc = zmq_recv(s, &query, 0);
        assert(rc == 0);

        query_string = (const char *)zmq_msg_data(&query);
        printf("recv: %s\n", query_string);
        zmq_msg_close(&query);

        rc = zmq_msg_init_size(&resultset, strlen(resultset_string)+1);
        assert(rc == 0);
        
        memcpy(zmq_msg_data(&resultset), resultset_string, strlen(resultset_string)+1);

        rc = zmq_send(s, &resultset, 0);
        assert(rc == 0);
        zmq_msg_close(&resultset);
    }

    return 0;
}
void test_bind_before_connect ()
{
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    // Bind first
    void *bindSocket = zmq_socket (ctx, ZMQ_PAIR);
    assert (bindSocket);
    int rc = zmq_bind (bindSocket, "inproc://bbc");
    assert (rc == 0);

    // Now connect
    void *connectSocket = zmq_socket (ctx, ZMQ_PAIR);
    assert (connectSocket);
    rc = zmq_connect (connectSocket, "inproc://bbc");
    assert (rc == 0);

    // Queue up some data
    rc = zmq_send_const (connectSocket, "foobar", 6, 0);
    assert (rc == 6);

    // Read pending message
    zmq_msg_t msg;
    rc = zmq_msg_init (&msg);
    assert (rc == 0);
    rc = zmq_msg_recv (&msg, bindSocket, 0);
    assert (rc == 6);
    void *data = zmq_msg_data (&msg);
    assert (memcmp ("foobar", data, 6) == 0);

    // Cleanup
    rc = zmq_close (connectSocket);
    assert (rc == 0);

    rc = zmq_close (bindSocket);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);
}
Example #14
0
/* send 100 messages over PAIR sockets
 * sender in one event handler, receiver in another
 */
void test_ev_zmq (void)
{
    struct ev_loop *loop;
    void *zctx;
    void *zin, *zout;
    int i;
    ev_zmq win, wout;

    ok ((loop = ev_loop_new (EVFLAG_AUTO)) != NULL,
        "ev_loop_new works");
    ok ((zctx = zmq_init (1)) != NULL,
        "initialized zmq context");
    ok ((zout = zmq_socket (zctx, ZMQ_PAIR)) != NULL
        && zmq_bind (zout, "inproc://eventloop_test") == 0,
        "PAIR socket bind ok");
    ok ((zin = zmq_socket (zctx, ZMQ_PAIR)) != NULL
        && zmq_connect (zin, "inproc://eventloop_test") == 0,
        "PAIR socket connect ok");

    i = 0;
    ev_zmq_init (&win, zsock_rx_cb, zin, EV_READ);
    win.data = &i;
    ev_zmq_init (&wout, zsock_tx_cb, zout, EV_WRITE);

    ev_zmq_start (loop, &win);
    ev_zmq_start (loop, &wout);

    ok (ev_run (loop, 0) == 0,
        "both watchers removed themselves and ev_run exited");
    ev_zmq_stop (loop, &win);
    ev_zmq_stop (loop, &wout);
    cmp_ok (i, "==", 100,
        "ev_zmq handler ran 100 times");

    ev_loop_destroy (loop);

    zmq_close (zin);
    zmq_close (zout);
    zmq_ctx_destroy (zctx);
}
Example #15
0
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 (false);

    //  Spawn the monitor socket endpoint
    rc = zmq_bind (monitor_socket, addr_);
    if (rc == -1)
         stop_monitor (false);
    return rc;
}
Example #16
0
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;
}
Example #17
0
bool ztop::InitialService(std::vector<std::pair<std::string, std::string>> servicePair, ztop*pztop)
{

	auto lambda_setsocket = [](std::pair<std::string, std::string>& sPair, ztop*pztop){
		void*s = zmq_socket(pztop->ctx, ZMQ_PUSH);
		int rc = zmq_bind(s, sPair.second.c_str());
		if (rc != -1)
		{
			pztop->pairs.insert(std::make_pair(sPair.first, s));
			pztop->vItems.push_back({ s, 0, ZMQ_POLLIN, 0 });
/*			pztop->jobSendSoketSets.insert(s);*/
			std::cerr << sPair.first << " start success:" << sPair.second << std::endl;
		}
		else
			std::cerr << __FUNCTION__ << ":"<<"service not start,with err:=====>" << zmq_strerror(zmq_errno());
	};
	for_each(servicePair.begin(), servicePair.end(), [&](std::pair<std::string, std::string>& sPair){
		lambda_setsocket(sPair, pztop);
	});

	return true;
}
Example #18
0
int main (void)
{
    void *context = zmq_ctx_new ();
    void *socket = zmq_socket (context, ZMQ_REP);
    zmq_bind (socket, "tcp://*:5555");

    s_catch_signals ();
    while (true) {
        //  Blocking read will exit on a signal
        zmq_msg_t message;
        zmq_msg_init (&message);
        zmq_msg_recv (&message, socket, 0);

        if (s_interrupted) {
            printf ("W: interrupt received, killing server...\n");
            break;
        }
    }
    zmq_close (socket);
    zmq_ctx_destroy (context);
    return 0;
}
Example #19
0
void test_leak (void)
{
    char my_endpoint[256];
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    void *sb = zmq_socket (ctx, ZMQ_REP);
    assert (sb);
    int rc = zmq_bind (sb, "ipc://*");
    assert (rc == 0);
    size_t len = sizeof(my_endpoint);
    rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
    assert (rc == 0);

    void *sc = zmq_socket (ctx, ZMQ_REQ);
    assert (sc);
    rc = zmq_connect (sc, my_endpoint);
    assert (rc == 0);

    rc = s_send (sc, "leakymsg");
    assert (rc == strlen ("leakymsg"));

    char *buf = s_recv (sb);
    free (buf);

    rc = zmq_close (sc);
    assert (rc == 0);

    msleep (SETTLE_TIME);

    rc = s_send (sb, "leakymsg");
    assert (rc == strlen ("leakymsg"));

    rc = zmq_close (sb);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);
}
Example #20
0
File: server.c Project: eselyavka/C
int main (void)
{
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int i=1;
    char skeystr[] = "JTKVSB%%)wK0E.X)V>+}o?pNmC{O&4W4b!Ni{Lh6";
    uint8_t server_key [32];
    zmq_z85_decode (server_key, skeystr);
    zmq_setsockopt(responder, ZMQ_CURVE_SERVER, &i, sizeof(i));
    zmq_setsockopt(responder, ZMQ_CURVE_SECRETKEY, &server_key, sizeof(server_key));
    int rc = zmq_bind (responder, "tcp://*:55555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}
Example #21
0
int main(void)
{
  void *ctx = zmq_ctx_new();
  void *sock = zmq_socket(ctx, ZMQ_ROUTER);
  int rc = zmq_bind(sock, "tcp://127.0.0.1:5555");
  assert(0 == rc);

  char buf[128];
  int recvBytes = 0;
  while (1) {
    // recv  id
    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    if (0 < recvBytes) {
      // send it back
      printf("recv id bytes=%d\n", recvBytes);

      zmq_send(sock, buf, recvBytes, ZMQ_SNDMORE);
    }

    // delimiter emtpy frame
    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    assert(0 == recvBytes);

    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    // actual message
    if (0 < recvBytes) {
      // send it back
      buf[recvBytes] = '\0';
      printf("recv msg %s, bytes=%d\n", buf, recvBytes);

      zmq_send(sock, "", 0, ZMQ_SNDMORE);
      zmq_send(sock, buf, recvBytes, 0);
    }
  }

  zmq_close(sock);
  zmq_ctx_destroy(ctx);
  return 0;
}
Example #22
0
int main (void)
{
    setup_test_environment();
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    void *sb = zmq_socket (ctx, ZMQ_REP);
    assert (sb);
    int rc = zmq_bind (sb, "inproc://a");
    assert (rc == 0);

    rc = zmq_unbind (sb, "inproc://a");
    assert (rc == 0);

    rc = zmq_close (sb);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);

    return 0;
}
static void
prep_server_socket(void * ctx, int set_heartbeats, int is_curve, void ** server_out, void ** mon_out)
{
    int rc;
    //  We'll be using this socket in raw mode
    void *server = zmq_socket (ctx, ZMQ_ROUTER);
    assert (server);

    int value = 0;
    rc = zmq_setsockopt (server, ZMQ_LINGER, &value, sizeof (value));
    assert (rc == 0);

    if(set_heartbeats) {
        value = 50;
        rc = zmq_setsockopt (server, ZMQ_HEARTBEAT_IVL, &value, sizeof(value));
        assert (rc == 0);
    }

    if(is_curve)
        setup_curve(server, 1);

    rc = zmq_bind (server, "tcp://127.0.0.1:5556");
    assert (rc == 0);

    //  Create and connect a socket for collecting monitor events on dealer
    void *server_mon = zmq_socket (ctx, ZMQ_PAIR);
    assert (server_mon);

    rc = zmq_socket_monitor (server, "inproc://monitor-dealer",
          ZMQ_EVENT_CONNECTED | ZMQ_EVENT_DISCONNECTED | ZMQ_EVENT_ACCEPTED);
    assert (rc == 0);

    //  Connect to the inproc endpoint so we'll get events
    rc = zmq_connect (server_mon, "inproc://monitor-dealer");
    assert (rc == 0);

    *server_out = server;
    *mon_out = server_mon;
}
Example #24
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;
}
Example #25
0
int main(void)
{
    // Prepare our context and socket
    void *context = zmq_ctx_new();
    void *receiver = zmq_socket(context, ZMQ_PULL);
    zmq_bind(receiver, "tcp://*:5558");

    // Wait for start of batch
    char *string = s_recv(receiver);
    free(string);
    printf("start of batch\n");

    // Start our clock now
    int64_t start_time = s_clock();

    // Process 100 confirmations
    int task_nbr;
    for(task_nbr=0; task_nbr<100; task_nbr++)
    {
        char *string = s_recv(receiver);
        free(string);
        if(task_nbr % 10 == 0)
        {
            printf(":");
        }
        else
        {
            printf(".");
        }
        fflush(stdout);
    }

    // Calculate and report duration of batch
    printf("\nTotal elapsed time: %d msec\n", (int)(s_clock() - start_time));
    
    zmq_close(receiver);
    zmq_ctx_destroy(context);
    return 0;
}
Example #26
0
//  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) {
    setup_test_environment ();
    void *ctx = zmq_ctx_new ();
    assert (ctx);
    
    void *stream = zmq_socket (ctx, ZMQ_STREAM);
    assert (stream);
    void *dealer = zmq_socket (ctx, ZMQ_DEALER);
    assert (dealer);
    
    int rc = zmq_bind (stream, "tcp://127.0.0.1:5555");
    assert (rc >= 0);
    rc = zmq_connect (dealer, "tcp://127.0.0.1:5555");
    assert (rc >= 0);
    zmq_send (dealer, "", 0, 0);
    
    zmq_msg_t ident, empty;
    zmq_msg_init (&ident);
    rc = zmq_msg_recv (&ident, stream, 0);
    assert (rc >= 0);
    rc = zmq_msg_init_data (&empty, (void *) "", 0, NULL, NULL);
    assert (rc >= 0);
    
    rc = zmq_msg_send (&ident, stream, ZMQ_SNDMORE);
    assert (rc >= 0);
    rc = zmq_msg_close (&ident);
    assert (rc >= 0);
    
    rc = zmq_msg_send (&empty, stream, 0);
    assert (rc >= 0);
    
    //  This close used to fail with Bad Address
    rc = zmq_msg_close (&empty);
    assert (rc >= 0);
    
    close_zero_linger (dealer);
    close_zero_linger (stream);
    zmq_ctx_term (ctx);
}
int main (void)
{
    int64_t more;
    size_t more_size = sizeof(more);

    setup_test_environment();
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    void *sb = zmq_socket (ctx, ZMQ_PUB);
    assert (sb);
    int rc = zmq_bind (sb, "inproc://a");
    assert (rc == 0);

    void *sc = zmq_socket (ctx, ZMQ_SUB);
    assert (sc);
    rc = zmq_connect (sc, "inproc://a");
    assert (rc == 0);

    memset(&more, 0xFF, sizeof(int64_t));
    zmq_getsockopt(sc, ZMQ_RCVMORE, &more, &more_size);
    assert (more_size == sizeof(int));
    assert (more == 0);


    // Cleanup

    rc = zmq_close (sc);
    assert (rc == 0);

    rc = zmq_close (sb);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);

    return 0 ;
}
Example #29
0
int main()
{
	struct ev_loop *loop = ev_default_loop(0);
	ev_signal signal_watcher;
	ev_signal *p_signal_watcher = &signal_watcher;
	ev_signal_init(p_signal_watcher, sigint_cb, SIGINT);
	ev_signal_start(loop, &signal_watcher);

	void *zctx = zmq_ctx_new();
	void *zsock_recv = zmq_socket(zctx, ZMQ_PULL);
	assert(zsock_recv!=NULL);
	int rc = zmq_bind(zsock_recv, "inproc://channel");
	assert(rc!=-1);

	ev_zsock_t wz;
	ev_zsock_init(&wz, zsock_cb, zsock_recv, EV_READ);
	ev_zsock_start(loop, &wz);

	void *zsock_send = zmq_socket(zctx, ZMQ_PUSH);
	assert(zsock_send!=NULL);
	rc = zmq_connect(zsock_send, "inproc://channel");
	assert(rc!=-1);

	ev_timer timeout_watcher;
	ev_timer *p_timeout_watcher = &timeout_watcher;
	ev_timer_init (p_timeout_watcher, timeout_cb, 1.0, 1.0);
	timeout_watcher.data = zsock_send;
	ev_timer_start (loop, &timeout_watcher);

	ev_run (loop, 0);
	printf("loop exited\n");

	zmq_close(zsock_recv);
	zmq_close(zsock_send);
	zmq_ctx_destroy(zctx);

	return 0;
}
Example #30
-1
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;
}