JNIEXPORT jlong JNICALL
Java_org_zeromq_czmq_Zsock__1_1newPull (JNIEnv *env, jclass c, jstring endpoint)
{
char *endpoint_ = (char *) (*env)->GetStringUTFChars (env, endpoint, NULL);
jlong new_pull_ = (jlong) (intptr_t) zsock_new_pull (endpoint_);
(*env)->ReleaseStringUTFChars (env, endpoint, endpoint_);
return new_pull_;
}
int
main()
{
zsock_t *receiver = zsock_new_pull("@tcp://*:7001");
assert(receiver != NULL);
while (1) {
char *msg = zstr_recv(receiver);
if (msg == NULL)
break;
printf("Received: %s\n", msg);
free(msg);
}
zsock_destroy(&receiver);
}
void
upstream_test (bool verbose)
{
printf (" * upstream: ");
// @selftest
zsock_t *pull = zsock_new_pull ("tcp://127.0.0.1:31337");
zactor_t *self = zactor_new (upstream_actor, NULL);
assert (self);
upstream_set_size (self, 4096);
int64_t size = upstream_get_size (self);
assert (size == 4096);
upstream_set_variance (self, 200);
int64_t variance = upstream_get_variance (self);
assert (variance == 200);
upstream_connect (self, "tcp://127.0.0.1:31337");
zmsg_t *msg = zmsg_recv (pull);
assert (msg);
zframe_t *frame = zmsg_pop (msg);
assert (frame);
int64_t content_size = (int64_t)zframe_size (frame);
assert (content_size >= size);
assert (content_size <= (size + variance));
zsock_destroy (&pull);
zframe_destroy (&frame);
zmsg_destroy (&msg);
zactor_destroy (&self);
// @end
printf ("OK\n");
}
int main(void) {
zmsg_t *msg;
zframe_t *frame;
char *str;
int i, rc;
// create push/pull sockets
zsock_t *push = zsock_new_push("inproc://example");
zsock_t *pull = zsock_new_pull("inproc://example");
// send multi-frame message
msg = zmsg_new();
zmsg_addmem(msg, "apple", 5);
zmsg_addmem(msg, "banana", 6);
zmsg_addmem(msg, "cherry", 6);
assert(zmsg_size(msg) == 3);
assert(zmsg_content_size(msg) == 5+6+6);
rc = zmsg_send(&msg, push);
assert(msg == NULL);
assert(rc == 0);
// receive multi-frame message
msg = zmsg_recv(pull);
assert(msg);
assert(zmsg_size(msg) == 3);
assert(zmsg_content_size(msg) == 5+6+6);
for (i = 0; i < 3; i++) {
str = zmsg_popstr(msg);
puts(str);
}
zmsg_destroy(&msg);
// disconnect
zsock_destroy(&push);
zsock_destroy(&pull);
return 0;
}
///
// Create a PULL socket. Default action is bind.
QZsock* QZsock::newPull (const QString &endpoint, QObject *qObjParent)
{
return new QZsock (zsock_new_pull (endpoint.toUtf8().data()), qObjParent);
}
void
zproxy_test (bool verbose)
{
printf (" * zproxy: ");
if (verbose)
printf ("\n");
// @selftest
// Create and configure our proxy
zactor_t *proxy = zactor_new (zproxy, NULL);
assert (proxy);
if (verbose) {
zstr_sendx (proxy, "VERBOSE", NULL);
zsock_wait (proxy);
}
zstr_sendx (proxy, "FRONTEND", "PULL", "inproc://frontend", NULL);
zsock_wait (proxy);
zstr_sendx (proxy, "BACKEND", "PUSH", "inproc://backend", NULL);
zsock_wait (proxy);
// Connect application sockets to proxy
zsock_t *faucet = zsock_new_push (">inproc://frontend");
assert (faucet);
zsock_t *sink = zsock_new_pull (">inproc://backend");
assert (sink);
// Send some messages and check they arrived
char *hello, *world;
zstr_sendx (faucet, "Hello", "World", NULL);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
// Test pause/resume functionality
zstr_sendx (proxy, "PAUSE", NULL);
zsock_wait (proxy);
zstr_sendx (faucet, "Hello", "World", NULL);
zsock_set_rcvtimeo (sink, 100);
zstr_recvx (sink, &hello, &world, NULL);
assert (!hello && !world);
zstr_sendx (proxy, "RESUME", NULL);
zsock_wait (proxy);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
// Test capture functionality
zsock_t *capture = zsock_new_pull ("inproc://capture");
assert (capture);
// Switch on capturing, check that it works
zstr_sendx (proxy, "CAPTURE", "inproc://capture", NULL);
zsock_wait (proxy);
zstr_sendx (faucet, "Hello", "World", NULL);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
zstr_recvx (capture, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
zsock_destroy (&faucet);
zsock_destroy (&sink);
zsock_destroy (&capture);
zactor_destroy (&proxy);
// @end
printf ("OK\n");
}
void
zsock_test (bool verbose)
{
printf (" * zsock: ");
// @selftest
zsock_t *writer = zsock_new_push ("@tcp://127.0.0.1:5560");
assert (writer);
assert (zsock_resolve (writer) != writer);
assert (streq (zsock_type_str (writer), "PUSH"));
int rc;
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3,2,0))
// Check unbind
rc = zsock_unbind (writer, "tcp://127.0.0.1:%d", 5560);
assert (rc == 0);
// In some cases and especially when running under Valgrind, doing
// a bind immediately after an unbind causes an EADDRINUSE error.
// Even a short sleep allows the OS to release the port for reuse.
zclock_sleep (100);
// Bind again
rc = zsock_bind (writer, "tcp://127.0.0.1:%d", 5560);
assert (rc == 5560);
assert (streq (zsock_endpoint (writer), "tcp://127.0.0.1:5560"));
#endif
zsock_t *reader = zsock_new_pull (">tcp://127.0.0.1:5560");
assert (reader);
assert (zsock_resolve (reader) != reader);
assert (streq (zsock_type_str (reader), "PULL"));
zstr_send (writer, "Hello, World");
zmsg_t *msg = zsock_recv (reader);
assert (msg);
char *string = zmsg_popstr (msg);
assert (streq (string, "Hello, World"));
free (string);
zmsg_destroy (&msg);
// Test binding to ephemeral ports, sequential and random
int port = zsock_bind (writer, "tcp://127.0.0.1:*");
assert (port >= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:*[50000-]");
assert (port >= 50000 && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:*[-50001]");
assert (port >= DYNAMIC_FIRST && port <= 50001);
port = zsock_bind (writer, "tcp://127.0.0.1:*[60000-60010]");
assert (port >= 60000 && port <= 60010);
port = zsock_bind (writer, "tcp://127.0.0.1:!");
assert (port >= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:![50000-]");
assert (port >= 50000 && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:![-50001]");
assert (port >= DYNAMIC_FIRST && port <= 50001);
port = zsock_bind (writer, "tcp://127.0.0.1:![60000-60010]");
assert (port >= 60000 && port <= 60010);
// Test zsock_endpoint method
rc = zsock_bind (writer, "inproc://test.%s", "writer");
assert (rc == 0);
assert (streq (zsock_endpoint (writer), "inproc://test.writer"));
// Test error state when connecting to an invalid socket type
// ('txp://' instead of 'tcp://', typo intentional)
rc = zsock_connect (reader, "txp://127.0.0.1:5560");
assert (rc == -1);
rc = zsock_signal (writer, 123);
assert (rc == 0);
rc = zsock_wait (reader);
assert (rc == 123);
zsock_destroy (&reader);
zsock_destroy (&writer);
// Test zsock_attach method
zsock_t *server = zsock_new (ZMQ_DEALER);
rc = zsock_attach (server, "@inproc://myendpoint,tcp://127.0.0.1:5556,inproc://others", true);
assert (rc == 0);
rc = zsock_attach (server, "", false);
assert (rc == 0);
rc = zsock_attach (server, NULL, true);
assert (rc == 0);
rc = zsock_attach (server, ">a,@b, c,, ", false);
assert (rc == -1);
zsock_destroy (&server);
// @end
printf ("OK\n");
}
Z K1(zsocknewpull){R ptr(zsock_new_pull(xs));}
///
// Create a PULL socket. Default action is bind.
QmlZsock *QmlZsockAttached::constructPull (const QString &endpoint) {
QmlZsock *qmlSelf = new QmlZsock ();
qmlSelf->self = zsock_new_pull (endpoint.toUtf8().data());
return qmlSelf;
};
///
// Create a PULL socket. Default action is bind.
QmlZsock *QmlZsockAttached::newPull (const QString &endpoint) {
QmlZsock *retQ_ = new QmlZsock ();
retQ_->self = zsock_new_pull (endpoint.toUtf8().data());
return retQ_;
};
