use of zmq.SocketBase in project jeromq by zeromq.
the class MetadataTest method testMetadata.
@Test
public void testMetadata() throws IOException, InterruptedException {
int port = Utils.findOpenPort();
String host = "tcp://127.0.0.1:" + port;
Ctx ctx = ZMQ.createContext();
// Spawn ZAP handler
// We create and bind ZAP socket in main thread to avoid case
// where child thread does not start up fast enough.
SocketBase handler = ZMQ.socket(ctx, ZMQ.ZMQ_REP);
assertThat(handler, notNullValue());
boolean rc = ZMQ.bind(handler, "inproc://zeromq.zap.01");
assertThat(rc, is(true));
Thread thread = new Thread(new ZapHandler(handler));
thread.start();
// Server socket will accept connections
SocketBase server = ZMQ.socket(ctx, ZMQ.ZMQ_DEALER);
assertThat(server, notNullValue());
SocketBase client = ZMQ.socket(ctx, ZMQ.ZMQ_DEALER);
assertThat(client, notNullValue());
ZMQ.setSocketOption(server, ZMQ.ZMQ_ZAP_DOMAIN, "DOMAIN");
rc = ZMQ.bind(server, host);
assertThat(rc, is(true));
rc = ZMQ.connect(client, host);
assertThat(rc, is(true));
int ret = ZMQ.send(client, "This is a message", 0);
assertThat(ret, is(17));
Msg msg = ZMQ.recv(server, 0);
assertThat(msg, notNullValue());
String prop = ZMQ.getMessageMetadata(msg, "Socket-Type");
assertThat(prop, is("DEALER"));
prop = ZMQ.getMessageMetadata(msg, "User-Id");
assertThat(prop, is("anonymous"));
prop = ZMQ.getMessageMetadata(msg, "Peer-Address");
assertThat(prop.startsWith("127.0.0.1:"), is(true));
prop = ZMQ.getMessageMetadata(msg, "no such");
assertThat(prop, nullValue());
prop = ZMQ.getMessageMetadata(msg, "Hello");
assertThat(prop, is("World"));
ZMQ.closeZeroLinger(server);
ZMQ.closeZeroLinger(client);
// Shutdown
ZMQ.term(ctx);
// Wait until ZAP handler terminates
thread.join();
}
use of zmq.SocketBase in project jeromq by zeromq.
the class SecurityCurveTest method testPlainCurveKeys.
@Test
public void testPlainCurveKeys() throws Exception {
byte[][] serverKeyPair = new Curve().keypair();
byte[] serverPublicKey = serverKeyPair[0];
byte[] serverSecretKey = serverKeyPair[1];
byte[][] clientKeyPair = new Curve().keypair();
byte[] clientPublicKey = clientKeyPair[0];
byte[] clientSecretKey = clientKeyPair[1];
Ctx context = ZMQ.createContext();
SocketBase server = context.createSocket(ZMQ.ZMQ_DEALER);
ZMQ.setSocketOption(server, ZMQ.ZMQ_CURVE_SERVER, true);
ZMQ.setSocketOption(server, ZMQ.ZMQ_CURVE_SECRETKEY, serverSecretKey);
server.bind(connectionString);
SocketBase client = context.createSocket(ZMQ.ZMQ_DEALER);
ZMQ.setSocketOption(client, ZMQ.ZMQ_CURVE_SERVERKEY, serverPublicKey);
ZMQ.setSocketOption(client, ZMQ.ZMQ_CURVE_PUBLICKEY, clientPublicKey);
ZMQ.setSocketOption(client, ZMQ.ZMQ_CURVE_SECRETKEY, clientSecretKey);
client.connect(connectionString);
byte[] testBytes = "hello-world".getBytes();
ZMQ.send(client, testBytes, 0);
byte[] recv = ZMQ.recv(server, 0).data();
assertThat(recv, is(equalTo(testBytes)));
server.close();
client.close();
context.terminate();
}
use of zmq.SocketBase in project jeromq by zeromq.
the class ProxyTest method testProxy.
@Test(timeout = 10000)
public void testProxy() throws Throwable {
// The main thread simply starts several clients and a server, and then
// waits for the server to finish.
Ctx ctx = ZMQ.createContext();
String controlEndpoint = "tcp://localhost:" + Utils.findOpenPort();
// Control socket receives terminate command from main over inproc
SocketBase control = ZMQ.socket(ctx, ZMQ.ZMQ_PUB);
assertThat(control, notNullValue());
boolean rc = ZMQ.bind(control, controlEndpoint);
assertThat(rc, is(true));
String host = "tcp://127.0.0.1:" + Utils.findOpenPort();
int count = 5;
ExecutorService executor = Executors.newFixedThreadPool(count + 1);
Server server = new Server(host, controlEndpoint, false);
Future<Boolean> fserver = executor.submit(server);
server.started.await();
List<Future<Boolean>> clientsf = new ArrayList<>(count);
for (int idx = 0; idx < count; ++idx) {
Client client = new Client(host, controlEndpoint, false);
clientsf.add(executor.submit(client));
client.started.await();
}
while (true) {
Thread.sleep(100);
int sent = ZMQ.send(control, ZMQ.PROXY_TERMINATE, 0);
assertThat(sent, is(9));
if (clientsf.get(4).isDone()) {
break;
}
}
for (Future<Boolean> client : clientsf) {
try {
assertThat(client.get(), is(true));
} catch (ExecutionException e) {
e.getCause().printStackTrace();
throw e.getCause();
}
}
ZMQ.close(control);
executor.shutdown();
if (!executor.awaitTermination(4, TimeUnit.SECONDS)) {
executor.shutdownNow();
fail("Hanged tasks");
}
ZMQ.term(ctx);
try {
assertThat(fserver.get(), is(true));
} catch (ExecutionException e) {
throw e.getCause();
}
}
use of zmq.SocketBase in project jeromq by zeromq.
the class TestPairTcp method testPairMonitorBindConnect.
@Test
public void testPairMonitorBindConnect() throws InterruptedException, IOException {
int port = Utils.findOpenPort();
String host = "tcp://127.0.0.1:" + port;
Ctx ctx = ZMQ.init(1);
assertThat(ctx, notNullValue());
SocketBase bind = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(bind, notNullValue());
boolean rc = ZMQ.bind(bind, host);
assertThat(rc, is(true));
SocketBase connect = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(connect, notNullValue());
rc = ZMQ.connect(connect, host);
assertThat(rc, is(true));
Helper.bounce(bind, connect);
SocketBase monitor = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(monitor, notNullValue());
rc = ZMQ.monitorSocket(connect, "inproc://events", ZMQ.ZMQ_EVENT_ALL);
assertThat(rc, is(true));
rc = ZMQ.bind(monitor, "inproc://events");
assertThat(rc, is(false));
rc = ZMQ.connect(monitor, "inproc://events");
assertThat(rc, is(true));
// Tear down the wiring.
ZMQ.close(bind);
ZMQ.close(connect);
ZMQ.close(monitor);
ZMQ.term(ctx);
}
use of zmq.SocketBase in project jeromq by zeromq.
the class TestPairTcp method testPairConnectSecondClientIssue285.
@Test
public void testPairConnectSecondClientIssue285() throws IOException {
String host = "tcp://127.0.0.1:*";
Ctx ctx = ZMQ.init(1);
assertThat(ctx, notNullValue());
SocketBase bind = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(bind, notNullValue());
boolean brc = ZMQ.bind(bind, host);
assertThat(brc, is(true));
host = (String) ZMQ.getSocketOptionExt(bind, ZMQ.ZMQ_LAST_ENDPOINT);
assertThat(host, notNullValue());
SocketBase first = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(first, notNullValue());
brc = ZMQ.connect(first, host);
assertThat(brc, is(true));
Helper.bounce(bind, first);
SocketBase second = ZMQ.socket(ctx, ZMQ.ZMQ_PAIR);
assertThat(second, notNullValue());
brc = ZMQ.connect(second, host);
assertThat(brc, is(true));
int ret = ZMQ.send(bind, "data", 0);
assertThat(ret, is(4));
ret = ZMQ.send(bind, "datb", 0);
assertThat(ret, is(4));
ret = ZMQ.send(bind, "datc", 0);
assertThat(ret, is(4));
ZMQ.msleep(100);
// no receiving from second connected pair
Msg msg = ZMQ.recv(second, ZMQ.ZMQ_DONTWAIT);
assertThat(msg, nullValue());
// receiving from first connected pair
msg = ZMQ.recv(first, ZMQ.ZMQ_DONTWAIT);
assertThat(msg, notNullValue());
assertThat(msg.data(), is("data".getBytes(ZMQ.CHARSET)));
msg = ZMQ.recv(first, ZMQ.ZMQ_DONTWAIT);
assertThat(msg, notNullValue());
assertThat(msg.data(), is("datb".getBytes(ZMQ.CHARSET)));
msg = ZMQ.recv(first, ZMQ.ZMQ_DONTWAIT);
assertThat(msg, notNullValue());
assertThat(msg.data(), is("datc".getBytes(ZMQ.CHARSET)));
// Tear down the wiring.
ZMQ.close(bind);
ZMQ.close(first);
ZMQ.close(second);
ZMQ.term(ctx);
}
Aggregations