it = timers.iterator();
while (it.hasNext()) {
STimer timer = it.next();
if (System.currentTimeMillis() >= timer.when && timer.when != -1) {
if (verbose)
System.out.println("I: zloop: call timer handler");
rc = timer.handler.handle(this, null, timer.arg);
if (rc == -1)
break; // Timer handler signalled break
if (timer.times != 0 && --timer.times == 0) {
it.remove();
} else
timer.when = timer.delay + System.currentTimeMillis();
}
}
if (rc == -1)
break; // Some timer signalled break from the reactor loop
// Handle any pollers that are ready
for (int itemNbr = 0; itemNbr < pollSize; itemNbr++) {
SPoller poller = pollact[itemNbr];
if (pollset.getItem(itemNbr).isError()) {
if (verbose)
System.out.printf("I: zloop: can't poll %s socket (%s, %s)",
poller.item.getSocket() != null ? poller.item.getSocket().getType() : "RAW",
poller.item.getSocket(), poller.item.getRawSocket());
// Give handler one chance to handle error, then kill
// poller because it'll disrupt the reactor otherwise.
if (poller.errors++ > 0) {
removePoller(poller.item);
}
} else
poller.errors = 0; // A non-error happened
if (pollset.getItem(itemNbr).readyOps() > 0) {
if (verbose)
System.out.printf("I: zloop: call %s socket handler (%s, %s)\n",
poller.item.getSocket() != null ? poller.item.getSocket().getType() : "RAW",
poller.item.getSocket(), poller.item.getRawSocket());
rc = poller.handler.handle(this, poller.item, poller.arg);
if (rc == -1)
break; // Poller handler signalled break
}
}
// Now handle any timer zombies
// This is going to be slow if we have many zombies
for (Object arg : zombies) {
it = timers.iterator();
while (it.hasNext()) {
STimer timer = it.next();
if (timer.arg == arg) {
it.remove();
}
}
}
// Now handle any new timers added inside the loop
timers.addAll(newTimers);
newTimers.clear();
if (rc == -1)
break;
}
return rc;
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMQ.java 0000664 0000000 0000000 00000233126 12360016021 0020544 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see .
*/
package org.zeromq;
import java.io.Closeable;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.channels.SelectableChannel;
import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* ZeroMQ JNI Bindings.
*
* @author Gonzalo Diethelm
*
*/
public class ZMQ {
static {
// if no embedded native library, revert to loading from java.library.path
if (!EmbeddedLibraryTools.LOADED_EMBEDDED_LIBRARY)
System.loadLibrary("jzmq");
}
// Values for flags in Socket's send and recv functions.
/**
* Socket flag to indicate a nonblocking send or recv mode.
*/
public static final int NOBLOCK = 1;
public static final int DONTWAIT = 1;
/**
* Socket flag to indicate that more message parts are coming.
*/
public static final int SNDMORE = 2;
// Socket types, used when creating a Socket.
/**
* Flag to specify a exclusive pair of items.
*/
public static final int PAIR = 0;
/**
* Flag to specify a PUB socket, receiving side must be a SUB or XSUB.
*/
public static final int PUB = 1;
/**
* Flag to specify the receiving part of the PUB or XPUB socket.
*/
public static final int SUB = 2;
/**
* Flag to specify a REQ socket, receiving side must be a REP.
*/
public static final int REQ = 3;
/**
* Flag to specify the receiving part of a REQ socket.
*/
public static final int REP = 4;
/**
* Flag to specify a DEALER socket (aka XREQ). DEALER is really a combined ventilator / sink that does
* load-balancing on output and fair-queuing on input with no other semantics. It is the only socket type that lets
* you shuffle messages out to N nodes and shuffle the replies back, in a raw bidirectional asynch pattern.
*/
public static final int DEALER = 5;
/**
* Old alias for DEALER flag. Flag to specify a XREQ socket, receiving side must be a XREP.
*
* @deprecated As of release 3.0 of zeromq, replaced by {@link #DEALER}
*/
public static final int XREQ = DEALER;
/**
* Flag to specify ROUTER socket (aka XREP). ROUTER is the socket that creates and consumes request-reply routing
* envelopes. It is the only socket type that lets you route messages to specific connections if you know their
* identities.
*/
public static final int ROUTER = 6;
/**
* Old alias for ROUTER flag. Flag to specify the receiving part of a XREQ socket.
*
* @deprecated As of release 3.0 of zeromq, replaced by {@link #ROUTER}
*/
public static final int XREP = ROUTER;
/**
* Flag to specify the receiving part of a PUSH socket.
*/
public static final int PULL = 7;
/**
* Flag to specify a PUSH socket, receiving side must be a PULL.
*/
public static final int PUSH = 8;
/**
* Flag to specify a XPUB socket, receiving side must be a SUB or XSUB. Subscriptions can be received as a message.
* Subscriptions start with a '1' byte. Unsubscriptions start with a '0' byte.
*/
public static final int XPUB = 9;
/**
* Flag to specify the receiving part of the PUB or XPUB socket. Allows
*/
public static final int XSUB = 10;
/**
* Flag to specify a STREAMER device.
*/
public static final int STREAMER = 1;
/**
* Flag to specify a FORWARDER device.
*/
public static final int FORWARDER = 2;
/**
* Flag to specify a QUEUE device.
*/
public static final int QUEUE = 3;
/**
* @see ZMQ#PULL
*/
@Deprecated
public static final int UPSTREAM = PULL;
/**
* @see ZMQ#PUSH
*/
@Deprecated
public static final int DOWNSTREAM = PUSH;
/**
* EVENT_CONNECTED: connection established.
* The EVENT_CONNECTED event triggers when a connection has been
* established to a remote peer. This can happen either synchronous
* or asynchronous. Value is the FD of the newly connected socket.
*/
public static final int EVENT_CONNECTED = 1;
/**
* EVENT_CONNECT_DELAYED: synchronous connect failed, it's being polled.
* The EVENT_CONNECT_DELAYED event triggers when an immediate connection
* attempt is delayed and its completion is being polled for. Value has
* no meaning.
*/
public static final int EVENT_CONNECT_DELAYED = 2;
/**
* EVENT_CONNECT_RETRIED: asynchronous connect / reconnection attempt.
* The EVENT_CONNECT_RETRIED event triggers when a connection attempt is
* being handled by reconnect timer. The reconnect interval's recomputed
* for each attempt. Value is the reconnect interval.
*/
public static final int EVENT_CONNECT_RETRIED = 4;
/**
* EVENT_LISTENING: socket bound to an address, ready to accept connections.
* The EVENT_LISTENING event triggers when a socket's successfully bound to
* a an interface. Value is the FD of the newly bound socket.
*/
public static final int EVENT_LISTENING = 8;
/**
* EVENT_BIND_FAILED: socket could not bind to an address.
* The EVENT_BIND_FAILED event triggers when a socket could not bind to a
* given interface. Value is the errno generated by the bind call.
*/
public static final int EVENT_BIND_FAILED = 16;
/**
* EVENT_ACCEPTED: connection accepted to bound interface.
* The EVENT_ACCEPTED event triggers when a connection from a remote peer
* has been established with a socket's listen address. Value is the FD of
* the accepted socket.
*/
public static final int EVENT_ACCEPTED = 32;
/**
* EVENT_ACCEPT_FAILED: could not accept client connection.
* The EVENT_ACCEPT_FAILED event triggers when a connection attempt to a
* socket's bound address fails. Value is the errno generated by accept.
*/
public static final int EVENT_ACCEPT_FAILED = 64;
/**
* EVENT_CLOSED: connection closed.
* The EVENT_CLOSED event triggers when a connection's underlying
* descriptor has been closed. Value is the former FD of the for the
* closed socket. FD has been closed already!
*/
public static final int EVENT_CLOSED = 128;
/**
* EVENT_CLOSE_FAILED: connection couldn't be closed.
* The EVENT_CLOSE_FAILED event triggers when a descriptor could not be
* released back to the OS. Implementation note: ONLY FOR IPC SOCKETS.
* Value is the errno generated by unlink.
*/
public static final int EVENT_CLOSE_FAILED = 256;
/**
* EVENT_DISCONNECTED: broken session.
* The EVENT_DISCONNECTED event triggers when the stream engine (tcp and
* ipc specific) detects a corrupted / broken session. Value is the FD of
* the socket.
*/
public static final int EVENT_DISCONNECTED = 512;
/**
* EVENT_MONITOR_STOPPED: monitor has been stopped.
* The EVENT_MONITOR_STOPPED event triggers when the monitor for a socket is
* stopped.
*/
public static final int EVENT_MONITOR_STOPPED = 1024;
/**
* EVENT_ALL: all events known by the java binding.
* The EVENT_ALL constant can be used to set up a monitor for all events known
* by the java binding. One could add more flags
*/
public static final int EVENT_ALL = EVENT_CONNECTED | EVENT_CONNECT_DELAYED | EVENT_CONNECT_RETRIED |
EVENT_LISTENING | EVENT_BIND_FAILED | EVENT_ACCEPTED | EVENT_ACCEPT_FAILED |
EVENT_CLOSED | EVENT_CLOSE_FAILED | EVENT_DISCONNECTED | EVENT_MONITOR_STOPPED;
/**
* @return Major version number of the ZMQ library.
*/
public static int getMajorVersion() {
return version_major();
}
/**
* @return Major version number of the ZMQ library.
*/
public static int getMinorVersion() {
return version_minor();
}
/**
* @return Major version number of the ZMQ library.
*/
public static int getPatchVersion() {
return version_patch();
}
/**
* @return Full version number of the ZMQ library used for comparing versions.
*/
public static int getFullVersion() {
return version_full();
}
/**
* @param major Version major component.
* @param minor Version minor component.
* @param patch Version patch component.
*
* @return Comparible single int version number.
*/
public static int makeVersion(final int major, final int minor, final int patch) {
return make_version(major, minor, patch);
}
/**
* @return String version number in the form major.minor.patch.
*/
public static String getVersionString() {
return String.format("%d.%d.%d", version_major(), version_minor(), version_patch());
}
/**
* Starts the built-in 0MQ proxy in the current application thread. The proxy connects a frontend socket to a
* backend socket. Conceptually, data flows from frontend to backend. Depending on the socket types, replies may
* flow in the opposite direction. The direction is conceptual only; the proxy is fully symmetric and there is no
* technical difference between frontend and backend.
*
* Before calling ZMQ.proxy() you must set any socket options, and connect or bind both frontend and backend
* sockets. The two conventional proxy models are:
*
* ZMQ.proxy() runs in the current thread and returns only if/when the current context is closed.
*
* @param frontend ZMQ.Socket
* @param backend ZMQ.Socket
* @param capture If the capture socket is not NULL, the proxy shall send all messages, received on both frontend
* and backend, to the capture socket. The capture socket should be a ZMQ_PUB, ZMQ_DEALER, ZMQ_PUSH, or
* ZMQ_PAIR socket.
* @since 3.2.2
*/
public static void proxy(Socket frontend, Socket backend, Socket capture) {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2))
throw new UnsupportedOperationException();
run_proxy(frontend, backend, capture);
}
/**
* Poll on polling items until timeout
*
* @param items polling items
* @param timeout timeout in millisecond
* @return number of events
*/
public static int poll(PollItem[] items, long timeout) {
return poll(items, items.length, timeout);
}
/**
* Poll on polling items until timeout
*
* @param items polling items
* @param count active item count
* @param timeout timeout in millisecond
* @return number of events
*/
public static int poll(PollItem[] items, int count, long timeout) {
return Poller.run_poll(items, count, timeout);
}
protected static native int version_full();
protected static native int version_major();
protected static native int version_minor();
protected static native int version_patch();
protected static native int make_version(int major, int minor, int patch);
protected static native long ENOTSUP();
protected static native long EPROTONOSUPPORT();
protected static native long ENOBUFS();
protected static native long ENETDOWN();
protected static native long EADDRINUSE();
protected static native long EADDRNOTAVAIL();
protected static native long ECONNREFUSED();
protected static native long EINPROGRESS();
protected static native long EHOSTUNREACH();
protected static native long EMTHREAD();
protected static native long EFSM();
protected static native long ENOCOMPATPROTO();
protected static native long ETERM();
protected static native long ENOTSOCK();
private static native void run_proxy(Socket frontend, Socket backend, Socket capture);
/**
* Inner class: Error.
*/
public enum Error {
ENOTSUP(ENOTSUP()),
EPROTONOSUPPORT(EPROTONOSUPPORT()),
ENOBUFS(ENOBUFS()),
ENETDOWN(ENETDOWN()),
EADDRINUSE(EADDRINUSE()),
EADDRNOTAVAIL(EADDRNOTAVAIL()),
ECONNREFUSED(ECONNREFUSED()),
EINPROGRESS(EINPROGRESS()),
EHOSTUNREACH(EHOSTUNREACH()),
EMTHREAD(EMTHREAD()),
EFSM(EFSM()),
ENOCOMPATPROTO(ENOCOMPATPROTO()),
ETERM(ETERM()),
ENOTSOCK(ENOTSOCK());
private final long code;
Error(long code) {
this.code = code;
}
public long getCode() {
return code;
}
public static Error findByCode(int code) {
for (Error e : Error.class.getEnumConstants()) {
if (e.getCode() == code) {
return e;
}
}
throw new IllegalArgumentException("Unknown " + Error.class.getName() + " enum code:" + code);
}
}
/**
* Create a new Context.
*
* @param ioThreads Number of threads to use, usually 1 is sufficient for most use cases.
* @return the Context
*/
public static Context context(int ioThreads) {
return new Context(ioThreads);
}
/**
* Inner class: Context.
*/
public static class Context implements Closeable {
private final AtomicBoolean closed = new AtomicBoolean(false);
/**
* This is an explicit "destructor". It can be called to ensure the corresponding 0MQ Context has been disposed
* of.
*/
public void term() {
if(closed.compareAndSet(false, true)) {
destroy();
}
}
/**
* Create a new Socket within this context.
*
* @param type the socket type.
* @return the newly created Socket.
*/
public Socket socket(int type) {
return new Socket(this, type);
}
/**
* Create a new Poller within this context, with a default size.
*
* @return the newly created Poller.
* @deprecated use Poller constructor
*/
public Poller poller() {
return new Poller(this);
}
/**
* Create a new Poller within this context, with a specified initial size.
*
* @param size the poller initial size.
* @return the newly created Poller.
* @deprecated use Poller constructor
*/
public Poller poller(int size) {
return new Poller(this, size);
}
/**
* Class constructor.
*
* @param ioThreads size of the threads pool to handle I/O operations.
*/
protected Context(int ioThreads) {
construct(ioThreads);
}
/** Initialize the JNI interface */
protected native void construct(int ioThreads);
/** Free all resources used by JNI interface. */
protected native void destroy();
/**
* Get the underlying context handle. This is private because it is only accessed from JNI, where Java access
* controls are ignored.
*
* @return the internal 0MQ context handle.
*/
private long getContextHandle() {
return this.contextHandle;
}
/** Opaque data used by JNI driver. */
private long contextHandle;
public void close() {
term();
}
/**
* Sets the maximum number of sockets allowed on the context
*/
public native boolean setMaxSockets(int maxSockets);
/**
* The maximum number of sockets allowed on the context
*/
public native int getMaxSockets();
}
/**
* Inner class: Socket.
*/
public static class Socket implements Closeable {
private static native void nativeInit();
static {
if (!EmbeddedLibraryTools.LOADED_EMBEDDED_LIBRARY)
System.loadLibrary("jzmq");
nativeInit();
}
private final AtomicBoolean closed = new AtomicBoolean(false);
/**
* This is an explicit "destructor". It can be called to ensure the corresponding 0MQ Socket has been disposed
* of.
*/
public void close() {
if(closed.compareAndSet(false, true)) {
destroy();
}
}
/**
* The 'ZMQ_TYPE option shall retrieve the socket type for the specified 'socket'. The socket type is specified
* at socket creation time and cannot be modified afterwards.
*
* @return the socket type.
* @since 2.1.0
*/
public int getType() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 0))
return -1;
return (int) getLongSockopt(TYPE);
}
/**
* @see #setLinger(long)
*
* @return the linger period.
* @since 2.1.0
*/
public long getLinger() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 0))
return -1;
return getLongSockopt(LINGER);
}
/**
* @see #setReconnectIVL(long)
*
* @return the reconnectIVL.
* @since 3.0.0
*/
public long getReconnectIVL() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 10))
return -1;
return getLongSockopt(RECONNECT_IVL);
}
/**
* @see #setBacklog(long)
*
* @return the backlog.
* @since 3.0.0
*/
public long getBacklog() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(BACKLOG);
}
/**
* @see #setReconnectIVLMax(long)
*
* @return the reconnectIVLMax.
* @since 3.0.0
*/
public long getReconnectIVLMax() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 10))
return -1;
return getLongSockopt(RECONNECT_IVL_MAX);
}
/**
* @see #setMaxMsgSize(long)
*
* @return the maxMsgSize.
* @since 3.0.0
*/
public long getMaxMsgSize() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(MAXMSGSIZE);
}
/**
* @see #setSndHWM(long)
*
* @return the SndHWM.
* @since 3.0.0
*/
public long getSndHWM() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(SNDHWM);
}
/**
* @see #setRcvHWM(long)
*
* @return the recvHWM period.
* @since 3.0.0
*/
public long getRcvHWM() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(RCVHWM);
}
/**
* @see #setHWM(long)
*
* @return the High Water Mark.
*/
public long getHWM() {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(HWM);
}
/**
* @see #setSwap(long)
*
* @return the number of messages to swap at most.
*/
public long getSwap() {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0))
return -1;
return getLongSockopt(SWAP);
}
/**
* @see #setAffinity(long)
*
* @return the affinity.
*/
public long getAffinity() {
return getLongSockopt(AFFINITY);
}
/**
* @see #setTCPKeepAlive(long)
*
* @return the keep alive setting.
*/
public long getTCPKeepAliveSetting() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 0))
return -1;
return getLongSockopt(KEEPALIVE);
}
/**
* @see #setTCPKeepAliveIdle(long)
*
* @return the keep alive idle value.
*/
public long getTCPKeepAliveIdle() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 0))
return -1;
return getLongSockopt(KEEPALIVEIDLE);
}
/**
* @see #setTCPKeepAliveInterval(long)
*
* @return the keep alive interval.
*/
public long getTCPKeepAliveInterval() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 0))
return -1;
return getLongSockopt(KEEPALIVEINTVL);
}
/**
* @see #setTCPKeepAliveCount(long)
*
* @return the keep alive count.
*/
public long getTCPKeepAliveCount() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 0))
return -1;
return getLongSockopt(KEEPALIVECNT);
}
/**
* @see #setIdentity(byte[])
*
* @return the Identitiy.
*/
public byte[] getIdentity() {
return getBytesSockopt(IDENTITY);
}
/**
* @see #setRate(long)
*
* @return the Rate.
*/
public long getRate() {
return getLongSockopt(RATE);
}
/**
* @see #setRecoveryInterval(long)
*
* @return the RecoveryIntervall.
*/
public long getRecoveryInterval() {
return getLongSockopt(RECOVERY_IVL);
}
/**
* @see #setMulticastLoop(boolean)
*
* @return the Multicast Loop.
*/
public boolean hasMulticastLoop() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return false;
return getLongSockopt(MCAST_LOOP) != 0;
}
/**
* Sets the time-to-live field in every multicast packet sent from this socket. The default is 1 which means
* that the multicast packets don't leave the local network.
*
* @param mcast_hops
*/
public void setMulticastHops(long mcast_hops) {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(MULTICAST_HOPS, mcast_hops);
}
/**
* @see #setMulticastHops(long)
*
* @return the Multicast Hops.
*/
public long getMulticastHops() {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return 1;
return getLongSockopt(MULTICAST_HOPS);
}
/**
* Sets the timeout for receive operation on the socket. If the value is 0, recv will return immediately, with a
* EAGAIN error if there is no message to receive. If the value is -1, it will block until a message is
* available. For all other values, it will wait for a message for that amount of time before returning with an
* EAGAIN error.
*
* @param timeout Timeout for receive operation in milliseconds. Default -1 (infinite)
*/
public void setReceiveTimeOut(int timeout) {
if (ZMQ.version_full() < ZMQ.make_version(2, 2, 0))
return;
setLongSockopt(RCVTIMEO, timeout);
}
/**
* @see #setReceiveTimeOut(int)
*
* @return the Receive Timeout in milliseconds
*/
public int getReceiveTimeOut() {
if (ZMQ.version_full() < ZMQ.make_version(2, 2, 0))
return -1;
return (int) getLongSockopt(RCVTIMEO);
}
/**
* Sets the timeout for send operation on the socket. If the value is 0, send will return immediately, with a
* EAGAIN error if the message cannot be sent. If the value is -1, it will block until the message is sent. For
* all other values, it will try to send the message for that amount of time before returning with an EAGAIN
* error.
*
* @param timeout Timeout for send operation in milliseconds. Default -1 (infinite)
*/
public void setSendTimeOut(int timeout) {
if (ZMQ.version_full() < ZMQ.make_version(2, 2, 0))
return;
setLongSockopt(SNDTIMEO, timeout);
}
/**
* @see #setSendTimeOut(int)
*
* @return the Send Timeout. in milliseconds
*/
public int getSendTimeOut() {
if (ZMQ.version_full() < ZMQ.make_version(2, 2, 0))
return -1;
return (int) getLongSockopt(SNDTIMEO);
}
/**
* @see #setSendBufferSize(long)
*
* @return the kernel send buffer size.
*/
public long getSendBufferSize() {
return getLongSockopt(SNDBUF);
}
/**
* @see #setReceiveBufferSize(long)
*
* @return the kernel receive buffer size.
*/
public long getReceiveBufferSize() {
return getLongSockopt(RCVBUF);
}
/**
* @see #setIPv4Only(boolean)
*
* @return the IPv4 only socket.
*/
public boolean getIPv4Only() {
return getLongSockopt(IPV4ONLY) == 1;
}
/**
* @see #setPlainServer(boolean)
*
* @return if the socket is setup for PLAIN security
*/
public boolean getPlainServer() {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
return getLongSockopt(PLAIN_SERVER) == 1;
}
return false;
}
/**
* @see #setPlainUsername(byte[])
*
* @return null terminated byte array in server charset
*/
public byte[] getPlainUsername() {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
return getBytesSockopt(PLAIN_USERNAME);
}
return null;
}
/**
* @see #setPlainPassword(byte[])
*
* @return null terminated byte array in server charset
*/
public byte[] getPlainPassword() {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
return getBytesSockopt(PLAIN_PASSWORD);
}
return null;
}
/**
* The 'ZMQ_RCVMORE' option shall return a boolean value indicating if the multi-part message currently being
* read from the specified 'socket' has more message parts to follow. If there are no message parts to follow or
* if the message currently being read is not a multi-part message a value of zero shall be returned. Otherwise,
* a value of 1 shall be returned.
*
* @return true if there are more messages to receive.
*/
public boolean hasReceiveMore() {
return getLongSockopt(RCVMORE) != 0;
}
/**
* The 'ZMQ_FD' option shall retrieve file descriptor associated with the 0MQ socket. The descriptor can be used
* to integrate 0MQ socket into an existing event loop. It should never be used for anything else than polling
* -- such as reading or writing. The descriptor signals edge-triggered IN event when something has happened
* within the 0MQ socket. It does not necessarily mean that the messages can be read or written. Check
* ZMQ_EVENTS option to find out whether the 0MQ socket is readable or writeable.
*
* @return the underlying file descriptor.
* @since 2.1.0
*/
public long getFD() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 0))
return -1;
return getLongSockopt(FD);
}
/**
* The 'ZMQ_EVENTS' option shall retrieve event flags for the specified socket. If a message can be read from
* the socket ZMQ_POLLIN flag is set. If message can be written to the socket ZMQ_POLLOUT flag is set.
*
* @return the mask of outstanding events.
* @since 2.1.0
*/
public long getEvents() {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 0))
return -1;
return getLongSockopt(EVENTS);
}
/**
* The 'ZMQ_LINGER' option shall retrieve the period for pending outbound messages to linger in memory after
* closing the socket. Value of -1 means infinite. Pending messages will be kept until they are fully
* transferred to the peer. Value of 0 means that all the pending messages are dropped immediately when socket
* is closed. Positive value means number of milliseconds to keep trying to send the pending messages before
* discarding them.
*
* @param linger the linger period.
* @since 2.1.0
*/
public void setLinger(long linger) {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 0))
return;
setLongSockopt(LINGER, linger);
}
/**
* @since 3.0.0
*/
public void setReconnectIVL(long reconnectIVL) {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 10))
return;
setLongSockopt(RECONNECT_IVL, reconnectIVL);
}
/**
* @since 3.0.0
*/
public void setBacklog(long backlog) {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(BACKLOG, backlog);
}
/**
* @since 3.0.0
*/
public void setReconnectIVLMax(long reconnectIVLMax) {
if (ZMQ.version_full() < ZMQ.make_version(2, 1, 10))
return;
setLongSockopt(RECONNECT_IVL_MAX, reconnectIVLMax);
}
/**
* @since 3.0.0
*/
public void setMaxMsgSize(long maxMsgSize) {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(MAXMSGSIZE, maxMsgSize);
}
/**
* @since 3.0.0
*/
public void setSndHWM(long sndHWM) {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(SNDHWM, sndHWM);
}
/**
* @since 3.0.0
*/
public void setRcvHWM(long rcvHWM) {
if (ZMQ.version_full() < ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(RCVHWM, rcvHWM);
}
/**
* The 'ZMQ_HWM' option shall set the high water mark for the specified 'socket'. The high water mark is a hard
* limit on the maximum number of outstanding messages 0MQ shall queue in memory for any single peer that the
* specified 'socket' is communicating with.
*
* If this limit has been reached the socket shall enter an exceptional state and depending on the socket type,
* 0MQ shall take appropriate action such as blocking or dropping sent messages. Refer to the individual socket
* descriptions in the man page of zmq_socket[3] for details on the exact action taken for each socket type.
*
* @param hwm the number of messages to queue.
*/
public void setHWM(long hwm) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(HWM, hwm);
}
/**
* Get the Swap. The 'ZMQ_SWAP' option shall set the disk offload (swap) size for the specified 'socket'. A
* socket which has 'ZMQ_SWAP' set to a non-zero value may exceed its high water mark; in this case outstanding
* messages shall be offloaded to storage on disk rather than held in memory.
*
* @param swap The value of 'ZMQ_SWAP' defines the maximum size of the swap space in bytes.
*/
public void setSwap(long swap) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(SWAP, swap);
}
/**
* Get the Affinity. The 'ZMQ_AFFINITY' option shall set the I/O thread affinity for newly created connections
* on the specified 'socket'.
*
* Affinity determines which threads from the 0MQ I/O thread pool associated with the socket's _context_ shall
* handle newly created connections. A value of zero specifies no affinity, meaning that work shall be
* distributed fairly among all 0MQ I/O threads in the thread pool. For non-zero values, the lowest bit
* corresponds to thread 1, second lowest bit to thread 2 and so on. For example, a value of 3 specifies that
* subsequent connections on 'socket' shall be handled exclusively by I/O threads 1 and 2.
*
* See also in the man page of zmq_init[3] for details on allocating the number of I/O threads for a specific
* _context_.
*
* @param affinity the affinity.
*/
public void setAffinity(long affinity) {
setLongSockopt(AFFINITY, affinity);
}
/**
* Override SO_KEEPALIVE socket option (where supported by OS) to enable keep-alive packets for a socket
* connection. Possible values are -1, 0, 1. The default value -1 will skip all overrides and do the OS default.
*
* @param optVal The value of 'ZMQ_TCP_KEEPALIVE' to turn TCP keepalives on (1) or off (0).
*/
public void setTCPKeepAlive(long optVal) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0))
setLongSockopt(KEEPALIVE, optVal);
}
/**
* Override TCP_KEEPCNT socket option (where supported by OS). The default value -1 will skip all overrides and
* do the OS default.
*
* @param optVal The value of 'ZMQ_TCP_KEEPALIVE_CNT' defines the number of keepalives before death.
*/
public void setTCPKeepAliveCount(long optVal) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0))
setLongSockopt(KEEPALIVECNT, optVal);
}
/**
* Override TCP_KEEPINTVL socket option (where supported by OS). The default value -1 will skip all overrides
* and do the OS default.
*
* @param optVal The value of 'ZMQ_TCP_KEEPALIVE_INTVL' defines the interval between keepalives. Unit is OS
* dependant.
*/
public void setTCPKeepAliveInterval(long optVal) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0))
setLongSockopt(KEEPALIVEINTVL, optVal);
}
/**
* Override TCP_KEEPCNT (or TCP_KEEPALIVE on some OS) socket option (where supported by OS). The default value
* -1 will skip all overrides and do the OS default.
*
* @param optVal The value of 'ZMQ_TCP_KEEPALIVE_IDLE' defines the interval between the last data packet sent
* over the socket and the first keepalive probe. Unit is OS dependant.
*/
public void setTCPKeepAliveIdle(long optVal) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0))
setLongSockopt(KEEPALIVEIDLE, optVal);
}
/**
* The 'ZMQ_IDENTITY' option shall set the identity of the specified 'socket'. Socket identity determines if
* existing 0MQ infastructure (_message queues_, _forwarding devices_) shall be identified with a specific
* application and persist across multiple runs of the application.
*
* If the socket has no identity, each run of an application is completely separate from other runs. However,
* with identity set the socket shall re-use any existing 0MQ infrastructure configured by the previous run(s).
* Thus the application may receive messages that were sent in the meantime, _message queue_ limits shall be
* shared with previous run(s) and so on.
*
* Identity should be at least one byte and at most 255 bytes long. Identities starting with binary zero are
* reserved for use by 0MQ infrastructure.
*
* @param identity
*/
public void setIdentity(byte[] identity) {
setBytesSockopt(IDENTITY, identity);
}
/**
* The 'ZMQ_SUBSCRIBE' option shall establish a new message filter on a 'ZMQ_SUB' socket. Newly created
* 'ZMQ_SUB' sockets shall filter out all incoming messages, therefore you should call this option to establish
* an initial message filter.
*
* An empty 'option_value' of length zero shall subscribe to all incoming messages. A non-empty 'option_value'
* shall subscribe to all messages beginning with the specified prefix. Mutiple filters may be attached to a
* single 'ZMQ_SUB' socket, in which case a message shall be accepted if it matches at least one filter.
*
* @param topic
*/
public void subscribe(byte[] topic) {
setBytesSockopt(SUBSCRIBE, topic);
}
/**
* The 'ZMQ_UNSUBSCRIBE' option shall remove an existing message filter on a 'ZMQ_SUB' socket. The filter
* specified must match an existing filter previously established with the 'ZMQ_SUBSCRIBE' option. If the socket
* has several instances of the same filter attached the 'ZMQ_UNSUBSCRIBE' option shall remove only one
* instance, leaving the rest in place and functional.
*
* @param topic
*/
public void unsubscribe(byte[] topic) {
setBytesSockopt(UNSUBSCRIBE, topic);
}
/**
* The 'ZMQ_RATE' option shall set the maximum send or receive data rate for multicast transports such as in the
* man page of zmq_pgm[7] using the specified 'socket'.
*
* @param rate
*/
public void setRate(long rate) {
setLongSockopt(RATE, rate);
}
/**
* The 'ZMQ_RECOVERY_IVL' option shall set the recovery interval for multicast transports using the specified
* 'socket'. The recovery interval determines the maximum time in seconds (before version 3.0.0) or milliseconds
* (version 3.0.0 and after) that a receiver can be absent from a multicast group before unrecoverable data loss
* will occur.
*
* CAUTION: Exercise care when setting large recovery intervals as the data needed for recovery will be held in
* memory. For example, a 1 minute recovery interval at a data rate of 1Gbps requires a 7GB in-memory buffer.
* {Purpose of this Method}
*
* @param recovery_ivl
*/
public void setRecoveryInterval(long recovery_ivl) {
setLongSockopt(RECOVERY_IVL, recovery_ivl);
}
/**
* The 'ZMQ_MCAST_LOOP' option shall control whether data sent via multicast transports using the specified
* 'socket' can also be received by the sending host via loopback. A value of zero disables the loopback
* functionality, while the default value of 1 enables the loopback functionality. Leaving multicast loopback
* enabled when it is not required can have a negative impact on performance. Where possible, disable
* 'ZMQ_MCAST_LOOP' in production environments.
*
* @param mcast_loop
*/
public void setMulticastLoop(boolean mcast_loop) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0))
return;
setLongSockopt(MCAST_LOOP, mcast_loop ? 1 : 0);
}
/**
* The 'ZMQ_SNDBUF' option shall set the underlying kernel transmit buffer size for the 'socket' to the
* specified size in bytes. A value of zero means leave the OS default unchanged. For details please refer to
* your operating system documentation for the 'SO_SNDBUF' socket option.
*
* @param sndbuf
*/
public void setSendBufferSize(long sndbuf) {
setLongSockopt(SNDBUF, sndbuf);
}
/**
* The 'ZMQ_RCVBUF' option shall set the underlying kernel receive buffer size for the 'socket' to the specified
* size in bytes. A value of zero means leave the OS default unchanged. For details refer to your operating
* system documentation for the 'SO_RCVBUF' socket option.
*
* @param rcvbuf
*/
public void setReceiveBufferSize(long rcvbuf) {
setLongSockopt(RCVBUF, rcvbuf);
}
/**
* The 'ZMQ_IPV4ONLY' option shall set the underlying native socket type. An IPv6 socket lets applications
* connect to and accept connections from both IPv4 and IPv6 hosts.
*
* @param v4only A value of true will use IPv4 sockets, while the value of false will use IPv6 sockets
*/
public void setIPv4Only(boolean v4only) {
setLongSockopt(IPV4ONLY, v4only ? 1L : 0L);
}
/**
* Sets the ROUTER socket behavior when an unroutable message is encountered.
*
* @param mandatory A value of false is the default and discards the message silently when it cannot be routed.
* A value of true returns an EHOSTUNREACH error code if the message cannot be routed.
*/
public void setRouterMandatory(boolean mandatory) {
setLongSockopt(ROUTER_MANDATORY, mandatory ? 1L : 0L);
}
/**
* Sets the XPUB socket behavior on new subscriptions and unsubscriptions.
*
* @param verbose A value of false is the default and passes only new subscription messages to upstream.
* A value of true passes all subscription messages upstream.
* @since 3.2.2
*/
public void setXpubVerbose(boolean verbose) {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2))
return;
setLongSockopt(XPUB_VERBOSE, verbose ? 1L : 0L);
}
/**
* Sets if the socket is for a server using the PLAIN security mechanism.
* @see PLAIN RFC
* @param plain whether or not to use PLAIN security
* @since 4.0.0
*/
public void setPlainServer(boolean plain) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setLongSockopt(PLAIN_SERVER, plain ? 1L : 0L);
}
}
/**
* Sets the username used for the PLAIN security mechanism.
* @see PLAIN RFC
* @param username null terminated string in server charset
* @since 4.0.0
*/
public void setPlainUsername(byte[] username) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setBytesSockopt(PLAIN_USERNAME, username);
}
}
/**
* Sets the password used for the PLAIN security mechanism.
* @see PLAIN RFC
* @param password null terminated string in server charset
* @since 4.0.0
*/
public void setPlainPassword(byte[] password) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setBytesSockopt(PLAIN_PASSWORD, password);
}
}
/**
* Sets the domain for ZAP (ZMQ RFC 27) authentication.
* @param domain For NULL security (the default on all tcp:// connections),
* ZAP authentication only happens if you set a non-empty domain. For PLAIN and CURVE security,
* ZAP requests are always made, if there is a ZAP handler present.
* See http://rfc.zeromq.org/spec:27 for more details.
*/
public void setZAPDomain(byte[] domain) {
if(ZMQ.version_full() >= ZMQ.make_version(4, 1, 0)) {
setBytesSockopt(ZAP_DOMAIN, domain);
}
}
public void setGSSAPIServer(boolean isServer) {
if(ZMQ.version_full() >= ZMQ.makeVersion(4, 1, 0)) {
setLongSockopt(GSSAPI_SERVER, isServer ? 1L : 0L);
}
}
public void setGSSAPIPrincipal(byte[] principal) {
if(ZMQ.version_full() >= ZMQ.make_version(4, 1, 0)) {
setBytesSockopt(GSSAPI_PRINCIPAL, principal);
}
}
public void setGSSAPIServicePrincipal(byte[] principal) {
if(ZMQ.version_full() >= ZMQ.make_version(4, 1, 0)) {
setBytesSockopt(GSSAPI_SERVICE_PRINCIPAL, principal);
}
}
public void setGSSAPIPlainText(boolean isPlaintext) {
if(ZMQ.version_full() >= ZMQ.makeVersion(4, 1, 0)) {
setLongSockopt(GSSAPI_PLAINTEXT, isPlaintext ? 1L : 0L);
}
}
/**
* Sets whether socket should keep only last received/to be sent message in its inbound/outbound queue.
*
* @param conflate A value of false is the default which means socket preserves all messages with respect
* to the RECVHWM and SENDHWM options. A value of true means only last message is kept ignoring
* the RECVHWM and SENDHWM options.
* @since 4.0.0
*/
public void setConflate(boolean conflate) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setLongSockopt(CONFLATE, conflate ? 1L : 0L);
}
}
/**
* Indicate whether socket should keep only last received/to be sent message in its inbound/outbound queue.
*
* @return true if should keep only last received/to be sent message in its inbound/outbound queue.
* @since 4.0.0
*/
public boolean getConflate() {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
return getLongSockopt(CONFLATE) != 0L;
}
else {
return false;
}
}
/**
* Indicate whether socket should only queue messages to completed connections.
*
* @return true if should only queue messages to completed connections.
* @since 3.2.0
*/
public boolean getImmediate() {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0)) {
return getLongSockopt(IMMEDIATE) != 0L;
}
else {
return false;
}
}
/**
* Sets whether socket should only queue messages to completed connections.
*
* @param immediate A value of false is the default which means socket will not queue messages to
* to incomplete connections. This will cause the socket to block if there are no other connections,
* but will prevent queues from filling on pipes awaiting connection.
* @since 3.2.0
*/
public void setImmediate(boolean immediate) {
if (ZMQ.version_full() >= ZMQ.make_version(3, 2, 0)) {
setLongSockopt(IMMEDIATE, immediate ? 1L : 0L);
}
}
public void setReqRelaxed(boolean isRelaxed) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setLongSockopt(REQ_RELAXED, isRelaxed ? 1L : 0L);
}
}
public void setReqCorrelate(boolean isCorrelate) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setLongSockopt(REQ_CORRELATE, isCorrelate ? 1L : 0L);
}
}
/**
* Sets whether the socket should automatically send an empty message
* when a new connection is made or accepted. This may be set on
* REQ, DEALER, or ROUTER sockets connected to a ROUTER socket.
* The application must filter such empty messages.
*
* @param isProbeRouter if {@code true}, the socket will automatically
* send an empty message when a new connection is made or
* accepted; if {@code false}, no such message will be sent
* @since 4.0.0
*/
public void setProbeRouter(boolean isProbeRouter) {
if (ZMQ.version_full() >= ZMQ.make_version(4, 0, 0)) {
setLongSockopt(PROBE_ROUTER, isProbeRouter ? 1L : 0L);
}
}
/**
* Bind to network interface. Start listening for new connections.
*
* @param addr the endpoint to bind to.
*/
public native void bind(String addr);
/**
* Bind to network interface to a random port. Start listening for new connections.
*
* @param addr the endpoint to bind to.
*/
public int bindToRandomPort(String addr) {
return bindToRandomPort(addr, 2000, 20000, 100);
}
/**
* Bind to network interface to a random port. Start listening for new connections.
*
* @param addr the endpoint to bind to.
* @param min_port The minimum port in the range of ports to try.
*/
public int bindToRandomPort(String addr, int min_port) {
return bindToRandomPort(addr, min_port, 20000, 100);
}
/**
* Bind to network interface to a random port. Start listening for new connections.
*
* @param addr the endpoint to bind to.
* @param min_port The minimum port in the range of ports to try.
* @param max_port The maximum port in the range of ports to try.
*/
public int bindToRandomPort(String addr, int min_port, int max_port) {
return bindToRandomPort(addr, min_port, max_port, 100);
}
/**
* Bind to network interface to a random port. Start listening for new connections.
*
* @param addr the endpoint to bind to.
* @param min_port The minimum port in the range of ports to try.
* @param max_port The maximum port in the range of ports to try.
* @param max_tries The number of attempt to bind.
*/
public int bindToRandomPort(String addr, int min_port, int max_port, int max_tries) {
int port;
Random rand = new Random();
for (int i = 0; i < max_tries; i++) {
port = rand.nextInt(max_port - min_port + 1) + min_port;
try {
bind(String.format("%s:%s", addr, port));
return port;
} catch (ZMQException e) {
if (e.getErrorCode() != ZMQ.EADDRINUSE()) {
throw e;
}
continue;
}
}
throw new ZMQException("Could not bind socket to random port.", (int) ZMQ.EADDRINUSE());
}
/**
* Unbind from network interface. Stop listening for connections.
*
* @param addr the endpoint to unbind from.
*/
public native void unbind(String addr);
/**
* Connect to remote application.
*
* @param addr the endpoint to connect to.
*/
public native void connect(String addr);
/**
* Disconnect from a remote application.
*
* @param addr the endpoint to disconnect from.
*/
public native void disconnect(String addr);
/**
* Start a monitoring socket where events can be received.
*
* @param addr the endpoint to receive events from. (must be inproc transport)
* @param events the events of interest.
* @return true if monitor socket setup is successful
* @throws ZMQException
*/
public native boolean monitor(String addr, int events) throws ZMQException;
/**
* Send a message.
*
* @param msg the message to send, as an array of bytes.
* @param offset the offset of the message to send.
* @param flags the flags to apply to the send operation.
* @return true if send was successful, false otherwise.
*/
public boolean send(byte[] msg, int offset, int flags) {
return send(msg, offset, msg.length, flags);
}
/**
*
* @param msg
* @param offset
* @param len
* @param flags
* @return
*/
public native boolean send(byte[] msg, int offset, int len, int flags);
/**
* Perform a zero copy send. The buffer must be allocated using ByteBuffer.allocateDirect
*
* @param buffer
* @param len
* @param flags
* @return
*/
public native boolean sendZeroCopy(ByteBuffer buffer, int len, int flags);
/**
* Send a message.
*
* @param msg the message to send, as an array of bytes.
* @param flags the flags to apply to the send operation.
* @return true if send was successful, false otherwise.
*/
public boolean send(byte[] msg, int flags) {
return send(msg, 0, msg.length, flags);
}
/**
* Send a String.
*
* @param msg the message to send, as a String.
* @return true if send was successful, false otherwise.
*/
public boolean send(String msg) {
byte[] b = msg.getBytes();
return send(b, 0, b.length, 0);
}
/**
* Send a String.
*
* @param msg the message to send, as a String.
* @return true if send was successful, false otherwise.
*/
public boolean sendMore(String msg) {
byte[] b = msg.getBytes();
return send(b, 0, b.length, SNDMORE);
}
/**
* Send a String.
*
* @param msg the message to send, as a String.
* @param flags the flags to apply to the send operation.
* @return true if send was successful, false otherwise.
*/
public boolean send(String msg, int flags) {
byte[] b = msg.getBytes();
return send(b, 0, b.length, flags);
}
/**
* Send a message
*
* @param bb ByteBuffer payload
* @param flags the flags to apply to the send operation
* @return the number of bytes sent
*/
public native int sendByteBuffer(ByteBuffer bb, int flags);
/**
* Receive a message.
*
* @param flags the flags to apply to the receive operation.
* @return the message received, as an array of bytes; null on error.
*/
public native byte[] recv(int flags);
/**
* Receive a message in to a specified buffer.
*
* @param buffer byte[] to copy zmq message payload in to.
* @param offset offset in buffer to write data
* @param len max bytes to write to buffer. If len is smaller than the incoming message size, the message will
* be truncated.
* @param flags the flags to apply to the receive operation.
* @return the number of bytes read, -1 on error
*/
public native int recv(byte[] buffer, int offset, int len, int flags);
/**
* Zero copy recv
*
* @param buffer
* @param len
* @param flags
* @return bytes read, -1 on error
*/
public native int recvZeroCopy(ByteBuffer buffer, int len, int flags);
/**
* Receive a message.
*
* @return the message received, as an array of bytes; null on error.
*/
public final byte[] recv() {
return recv(0);
}
/**
* Receive a message as a String with the default Charset.
*
* @deprecated use {@link #recvStr(Charset)} instead.
* @return the message received, as a String; null on error.
*/
@Deprecated
public String recvStr() {
return recvStr(0);
}
/**
* Receive a message as a String with a given Charset.
*
* @param charset the charset of the resulting string.
* @return the message received, as a String; null on error.
*/
public String recvStr(Charset charset) {
return recvStr(0, charset);
}
/**
* Receive a message as a String with the default charset.
*
* @deprecated use {@link #recvStr(int, Charset)} instead.
* @param flags the flags to apply to the receive operation.
* @return the message received, as a String; null on error.
*/
@Deprecated
public String recvStr(int flags) {
return recvStr(flags, Charset.defaultCharset());
}
/**
* Receive a message as a String.
*
* @param flags the flags to apply to the receive operation.
* @param charset the charset of the resulting string.
* @return the message received, as a String; null on error.
*/
public String recvStr(int flags, Charset charset) {
byte[] data = recv(flags);
if (data == null) {
return null;
} else {
return new String(data, charset);
}
}
/**
* Receive a message
*
* @param buffer
* @param flags
* @return bytes read, -1 on error
*/
public native int recvByteBuffer(ByteBuffer buffer, int flags);
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param type the socket type.
*/
protected Socket(Context context, int type) {
// We keep a local handle to context so that
// garbage collection won't be too greedy on it.
this.context = context;
construct(context, type);
}
/** Initialize the JNI interface */
protected native void construct(Context ctx, int type);
/** Free all resources used by JNI interface. */
protected native void destroy();
/**
* Get the socket option value, as a long.
*
* @param option ID of the option to set.
* @return The socket option value (as a long).
*/
protected native long getLongSockopt(int option);
/**
* Get the socket option value, as a byte array.
*
* @param option ID of the option to set.
* @return The socket option value (as a byte array).
*/
protected native byte[] getBytesSockopt(int option);
/**
* Set the socket option value, given as a long.
*
* @param option ID of the option to set.
* @param optval value (as a long) to set the option to.
*/
protected native void setLongSockopt(int option, long optval);
/**
* Set the socket option value, given as a byte array.
*
* @param option ID of the option to set.
* @param optval value (as a byte array) to set the option to.
*/
protected native void setBytesSockopt(int option, byte[] optval);
/**
* Get the underlying socket handle. This is private because it is only accessed from JNI, where Java access
* controls are ignored.
*
* @return the internal 0MQ socket handle.
*/
private long getSocketHandle() {
return this.socketHandle;
}
/** Opaque data used by JNI driver. */
private long socketHandle;
private final Context context;
// private Constants use the appropriate setter instead.
private static final int HWM = 1;
// public static final int LWM = 2; // No longer supported
private static final int SWAP = 3;
private static final int AFFINITY = 4;
private static final int IDENTITY = 5;
private static final int SUBSCRIBE = 6;
private static final int UNSUBSCRIBE = 7;
private static final int RATE = 8;
private static final int RECOVERY_IVL = 9;
private static final int MCAST_LOOP = 10;
private static final int SNDBUF = 11;
private static final int RCVBUF = 12;
private static final int RCVMORE = 13;
private static final int FD = 14;
private static final int EVENTS = 15;
private static final int TYPE = 16;
private static final int LINGER = 17;
private static final int RECONNECT_IVL = 18;
private static final int BACKLOG = 19;
private static final int RECONNECT_IVL_MAX = 21;
private static final int MAXMSGSIZE = 22;
private static final int SNDHWM = 23;
private static final int RCVHWM = 24;
private static final int MULTICAST_HOPS = 25;
private static final int RCVTIMEO = 27;
private static final int SNDTIMEO = 28;
private static final int IPV4ONLY = 31;
private static final int ROUTER_MANDATORY = 33;
private static final int KEEPALIVE = 34;
private static final int KEEPALIVECNT = 35;
private static final int KEEPALIVEIDLE = 36;
private static final int KEEPALIVEINTVL = 37;
private static final int IMMEDIATE = 39;
private static final int XPUB_VERBOSE = 40;
private static final int PLAIN_SERVER = 44;
private static final int PLAIN_USERNAME = 45;
private static final int PLAIN_PASSWORD = 46;
private static final int PROBE_ROUTER = 51;
private static final int REQ_CORRELATE = 52;
private static final int REQ_RELAXED = 53;
private static final int CONFLATE = 54;
private static final int ZAP_DOMAIN = 55;
private static final int GSSAPI_SERVER = 62;
private static final int GSSAPI_PRINCIPAL = 63;
private static final int GSSAPI_SERVICE_PRINCIPAL = 64;
private static final int GSSAPI_PLAINTEXT = 65;
}
public static class PollItem {
private Socket socket;
private SelectableChannel channel;
private int events;
private int revents;
public PollItem(Socket socket, int events) {
this.socket = socket;
this.events = events;
this.revents = 0;
}
public PollItem(SelectableChannel channel, int events) {
this.channel = channel;
this.events = events;
this.revents = 0;
}
public SelectableChannel getRawSocket() {
return channel;
}
public Socket getSocket() {
return socket;
}
public boolean isError() {
return (revents & Poller.POLLERR) > 0;
}
public int readyOps() {
return revents;
}
public boolean isReadable() {
return (revents & Poller.POLLIN) > 0;
}
public boolean isWritable() {
return (revents & Poller.POLLOUT) > 0;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof PollItem))
return false;
PollItem target = (PollItem) obj;
if (socket != null && socket == target.socket)
return true;
if (channel != null && channel == target.channel)
return true;
return false;
}
}
/**
* Inner class: Poller.
*/
public static class Poller {
/**
* These values can be ORed to specify what we want to poll for.
*/
public static final int POLLIN = 1;
public static final int POLLOUT = 2;
public static final int POLLERR = 4;
/**
* Register a Socket for polling on all events.
*
* @param socket the Socket we are registering.
* @return the index identifying this Socket in the poll set.
*/
public int register(Socket socket) {
return register(socket, POLLIN | POLLOUT | POLLERR);
}
/**
* Register a Channel for polling on all events.
*
* @param channel the Channel we are registering.
* @return the index identifying this Channel in the poll set.
*/
public int register(SelectableChannel channel) {
return register(channel, POLLIN | POLLOUT | POLLERR);
}
/**
* Register a Socket for polling on the specified events.
*
* Automatically grow the internal representation if needed.
*
* @param socket the Socket we are registering.
* @param events a mask composed by XORing POLLIN, POLLOUT and POLLERR.
* @return the index identifying this Socket in the poll set.
*/
public int register(Socket socket, int events) {
return registerInternal(new PollItem(socket, events));
}
/**
* Register a Channel for polling on the specified events.
*
* Automatically grow the internal representation if needed.
*
* @param channel the Channel we are registering.
* @param events a mask composed by XORing POLLIN, POLLOUT and POLLERR.
* @return the index identifying this Channel in the poll set.
*/
public int register(SelectableChannel channel, int events) {
return registerInternal(new PollItem(channel, events));
}
/**
* Register a Channel for polling on the specified events.
*
* Automatically grow the internal representation if needed.
*
* @param item the PollItem we are registering.
* @return the index identifying this Channel in the poll set.
*/
public int register(PollItem item) {
return registerInternal(item);
}
/**
* Register a Socket for polling on the specified events.
*
* Automatically grow the internal representation if needed.
*
* @param item the PollItem we are registering.
* @return the index identifying this Socket in the poll set.
*/
private int registerInternal(PollItem item) {
int pos = -1;
if (!this.freeSlots.isEmpty()) {
// If there are free slots in our array, remove one
// from the free list and use it.
pos = this.freeSlots.remove();
} else {
if (this.next >= this.size) {
// It is necessary to grow the arrays.
// Compute new size for internal arrays.
int nsize = this.size + SIZE_INCREMENT;
// Create new internal arrays.
PollItem[] ns = new PollItem[nsize];
short[] ne = new short[nsize];
short[] nr = new short[nsize];
// Copy contents of current arrays into new arrays.
for (int i = 0; i < this.next; ++i) {
ns[i] = this.items[i];
}
// Swap internal arrays and size to new values.
this.size = nsize;
this.items = ns;
}
pos = this.next++;
}
this.items[pos] = item;
this.used++;
return pos;
}
/**
* Unregister a Socket for polling on the specified events.
*
* @param socket the Socket to be unregistered
*/
public void unregister(Socket socket) {
unregisterInternal(socket);
}
/**
* Unregister a Channel for polling on the specified events.
*
* @param channel the Channel to be unregistered
*/
public void unregister(SelectableChannel channel) {
unregisterInternal(channel);
}
/**
* Unregister a Socket for polling on the specified events.
*
* @param socket the Socket to be unregistered
*/
private void unregisterInternal(Object socket) {
for (int i = 0; i < this.next; ++i) {
PollItem item = this.items[i];
if (item == null) {
continue;
}
if (item.socket == socket || item.channel == socket) {
this.items[i] = null;
this.freeSlots.add(i);
--this.used;
break;
}
}
}
/**
* Get the socket associated with an index.
*
* @param index the desired index.
* @return the Socket associated with that index (or null).
*/
public Socket getSocket(int index) {
if (index < 0 || index >= this.next)
return null;
return this.items[index].socket;
}
/**
* Get the PollItem associated with an index.
*
* @param index the desired index.
* @return the PollItem associated with that index (or null).
*/
public PollItem getItem(int index) {
if (index < 0 || index >= this.next)
return null;
return this.items[index];
}
/**
* Get the current poll timeout.
*
* @return the current poll timeout in microseconds.
* @deprecated Timeout handling has been moved to the poll() methods.
*/
public long getTimeout() {
return this.timeout;
}
/**
* Set the poll timeout.
*
* @param timeout the desired poll timeout in microseconds.
* @deprecated Timeout handling has been moved to the poll() methods.
*/
public void setTimeout(long timeout) {
if (timeout < -1)
return;
this.timeout = timeout;
}
/**
* Get the current poll set size.
*
* @return the current poll set size.
*/
public int getSize() {
return this.size;
}
/**
* Get the index for the next position in the poll set size.
*
* @return the index for the next position in the poll set size.
*/
public int getNext() {
return this.next;
}
/**
* Issue a poll call. If the poller's internal timeout value has been set, use that value as timeout; otherwise,
* block indefinitely.
*
* @return how many objects where signalled by poll ().
*/
public long poll() {
long tout = -1;
if (this.timeout > -1) {
tout = this.timeout;
}
return poll(tout);
}
/**
* Issue a poll call, using the specified timeout value.
*
* Since ZeroMQ 3.0, the timeout parameter is in milliseconds,
* but prior to this the unit was microseconds.
*
* @param tout the timeout, as per zmq_poll if -1, it will block
* indefinitely until an event happens; if 0, it will
* return immediately; otherwise, it will wait for at most
* that many milliseconds/microseconds (see above).
*
* @see 2.1 docs
* @see 3.0 docs
*
* @return how many objects where signalled by poll ()
*/
public int poll(long tout) {
if (tout < -1) {
return 0;
}
if (this.size <= 0 || this.next <= 0) {
return 0;
}
return run_poll(this.items, this.used, tout);
}
/**
* Check whether the specified element in the poll set was signalled for input.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollin(int index) {
return poll_mask(index, POLLIN);
}
/**
* Check whether the specified element in the poll set was signalled for output.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollout(int index) {
return poll_mask(index, POLLOUT);
}
/**
* Check whether the specified element in the poll set was signalled for error.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollerr(int index) {
return poll_mask(index, POLLERR);
}
/**
* Constructor
*
* @param size the number of Sockets this poller will contain.
*/
public Poller(int size) {
this(null, size);
}
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
*/
protected Poller(Context context) {
this(context, SIZE_DEFAULT);
}
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param size the number of Sockets this poller will contain.
*/
protected Poller(Context context, int size) {
this.context = context;
this.size = size;
this.next = 0;
this.items = new PollItem[this.size];
freeSlots = new LinkedList();
}
/**
* Issue a poll call on the specified 0MQ items.
*
* Since ZeroMQ 3.0, the timeout parameter is in milliseconds, but prior to this the unit was
* microseconds.
*
* @param items an array of PollItem to poll.
* @param timeout the maximum timeout in milliseconds/microseconds (see above).
* @return how many objects where signalled by poll.
* @see 2.1 docs
* @see 3.0 docs
*/
protected native static int run_poll(PollItem[] items, int count, long timeout);
/**
* Check whether a specific mask was signalled by latest poll call.
*
* @param index the index indicating the socket.
* @param mask a combination of POLLIN, POLLOUT and POLLERR.
* @return true if specific socket was signalled as specified.
*/
private boolean poll_mask(int index, int mask) {
if (mask <= 0 || index < 0 || index >= this.next || this.items[index] == null) {
return false;
}
return (this.items[index].revents & mask) > 0;
}
private Context context = null;
private long timeout = -2; // mark as uninitialized
private int size = 0;
private int next = 0;
private int used = 0;
private PollItem[] items = null;
// When socket is removed from polling, store free slots here
private LinkedList freeSlots = null;
private static final int SIZE_DEFAULT = 32;
private static final int SIZE_INCREMENT = 16;
}
/**
* Inner class: Event.
* Monitor socket event class
*/
public static class Event {
private static native void nativeInit();
static {
nativeInit();
}
private final int event;
private final Object value;
private final String address;
private Event(int event, int value, String address) {
this(event, Integer.valueOf(value), address != null ? address : "");
}
public Event(int event, Object value, String address) {
this.event = event;
this.value = value;
this.address = address;
}
public int getEvent() {
return event;
}
public Object getValue() {
return value;
}
/**
* Get the address.
* For libzmq versions 3.2.x the address will be an empty string.
* @return
*/
public String getAddress() {
return address;
}
private static native Event recv(long socket, int flags) throws ZMQException;
/**
* Receive an event from a monitor socket.
* For libzmq versions 3.2.x the address will be an empty string.
* @param socket the socket
* @param flags the flags to apply to the receive operation.
* @return the received event or null if no message was received.
* @throws ZMQException
*/
public static Event recv(Socket socket, int flags) throws ZMQException {
return Event.recv(socket.socketHandle, flags);
}
/**
* Receive an event from a monitor socket.
* Does a blocking recv.
* For libzmq versions 3.2.x the address will be an empty string.
* @param socket the socket
* @return the received event.
* @throws ZMQException
*/
public static Event recv(Socket socket) throws ZMQException {
return Event.recv(socket, 0);
}
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMQException.java 0000664 0000000 0000000 00000001200 12360016021 0022405 0 ustar 00root root 0000000 0000000 package org.zeromq;
/**
* ZeroMQ runtime exception.
*
* @author Alois Belaska <alois.belaska@gmail.com>
*/
public class ZMQException extends RuntimeException {
private static final long serialVersionUID = -978820750094924644L;
private int errorCode = 0;
public ZMQException(String message, int errorCode) {
super(message);
this.errorCode = errorCode;
}
/**
* @return error code
*/
public int getErrorCode() {
return errorCode;
}
@Override
public String toString() {
return super.toString() + "(0x" + Integer.toHexString(errorCode) + ")";
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMQForwarder.java 0000664 0000000 0000000 00000003137 12360016021 0022415 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;
/**
* ZeroMQ Forwarder Device implementation.
*
* @author Alois Belaska <alois.belaska@gmail.com>
*/
public class ZMQForwarder implements Runnable {
private final ZMQ.Poller poller;
private final ZMQ.Socket inSocket;
private final ZMQ.Socket outSocket;
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param inSocket input socket
* @param outSocket output socket
*/
public ZMQForwarder(Context context, Socket inSocket, Socket outSocket) {
this.inSocket = inSocket;
this.outSocket = outSocket;
this.poller = context.poller(1);
this.poller.register(inSocket, ZMQ.Poller.POLLIN);
}
/**
* Forwarding messages.
*/
@Override
public void run() {
byte[] msg = null;
boolean more = true;
while (!Thread.currentThread().isInterrupted()) {
try {
// wait while there are requests to process
if (poller.poll(250000) < 1) {
continue;
}
msg = inSocket.recv(0);
more = inSocket.hasReceiveMore();
if (msg != null) {
outSocket.send(msg, more ? ZMQ.SNDMORE : 0);
}
} catch (ZMQException e) {
// context destroyed, exit
if (ZMQ.Error.ETERM.getCode() == e.getErrorCode()) {
break;
}
throw e;
}
}
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMQQueue.java 0000664 0000000 0000000 00000005120 12360016021 0021540 0 ustar 00root root 0000000 0000000 package org.zeromq;
import java.io.Closeable;
import java.io.IOException;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;
/**
* ZeroMQ Queue Device implementation.
*
* @author Alois Belaska <alois.belaska@gmail.com>
*/
public class ZMQQueue implements Runnable, Closeable {
private final ZMQ.Poller poller;
private final ZMQ.Socket inSocket;
private final ZMQ.Socket outSocket;
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param inSocket input socket
* @param outSocket output socket
*/
public ZMQQueue(Context context, Socket inSocket, Socket outSocket) {
this.inSocket = inSocket;
this.outSocket = outSocket;
this.poller = context.poller(2);
this.poller.register(inSocket, ZMQ.Poller.POLLIN);
this.poller.register(outSocket, ZMQ.Poller.POLLIN);
}
/**
* Queuing of requests and replies.
*/
@Override
public void run() {
byte[] msg = null;
boolean more = true;
while (!Thread.currentThread().isInterrupted()) {
try {
// wait while there are either requests or replies to process
if (poller.poll(-1) < 0) {
break;
}
// process a request
if (poller.pollin(0)) {
more = true;
while (more) {
msg = inSocket.recv(0);
more = inSocket.hasReceiveMore();
if (msg != null) {
outSocket.send(msg, more ? ZMQ.SNDMORE : 0);
}
}
}
// process a reply
if (poller.pollin(1)) {
more = true;
while (more) {
msg = outSocket.recv(0);
more = outSocket.hasReceiveMore();
if (msg != null) {
inSocket.send(msg, more ? ZMQ.SNDMORE : 0);
}
}
}
} catch (ZMQException e) {
// context destroyed, exit
if (ZMQ.Error.ETERM.getCode() == e.getErrorCode()) {
break;
}
throw e;
}
}
}
/**
* Unregisters input and output sockets.
*/
@Override
public void close() throws IOException {
poller.unregister(this.inSocket);
poller.unregister(this.outSocket);
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMQStreamer.java 0000664 0000000 0000000 00000001051 12360016021 0022235 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;
/**
* ZeroMQ Streamer Device implementation.
*
* @author Alois Belaska <alois.belaska@gmail.com>
*/
public class ZMQStreamer extends ZMQForwarder {
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param inSocket input socket
* @param outSocket output socket
*/
public ZMQStreamer(Context context, Socket inSocket, Socket outSocket) {
super(context, inSocket, outSocket);
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZMsg.java 0000664 0000000 0000000 00000036524 12360016021 0020760 0 ustar 00root root 0000000 0000000 package org.zeromq;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.zeromq.ZMQ.Socket;
/**
* The ZMsg class provides methods to send and receive multipart messages across 0MQ sockets. This class provides a
* list-like container interface, with methods to work with the overall container. ZMsg messages are composed of zero or
* more ZFrame objects.
*
*
* // Send a simple single-frame string message on a ZMQSocket "output" socket object
* ZMsg.newStringMsg("Hello").send(output);
*
* // Add several frames into one message
* ZMsg msg = new ZMsg();
* for (int i = 0; i < 10; i++) {
* msg.addString("Frame" + i);
* }
* msg.send(output);
*
* // Receive message from ZMQSocket "input" socket object and iterate over frames
* ZMsg receivedMessage = ZMsg.recvMsg(input);
* for (ZFrame f : receivedMessage) {
* // Do something with frame f (of type ZFrame)
* }
*
*
* Based on zmsg.c in czmq
*
*/
public class ZMsg implements Iterable, Deque {
/**
* Hold internal list of ZFrame objects
*/
private ArrayDeque frames;
/**
* Class Constructor
*/
public ZMsg() {
frames = new ArrayDeque();
}
/**
* Destructor. Explicitly destroys all ZFrames contains in the ZMsg
*/
public void destroy() {
if (frames == null)
return;
for (ZFrame f : frames) {
f.destroy();
}
frames.clear();
}
/**
* Return total number of bytes contained in all ZFrames in this ZMsg
*
* @return
*/
public long contentSize() {
long size = 0;
for (ZFrame f : frames) {
size += f.size();
}
return size;
}
/**
* Add a String as a new ZFrame to the end of list
*
* @param str String to add to list
*/
public void addString(String str) {
if (frames == null)
frames = new ArrayDeque();
frames.add(new ZFrame(str));
}
/**
* Creates copy of this ZMsg. Also duplicates all frame content.
*
* @return The duplicated ZMsg object, else null if this ZMsg contains an empty frame set
*/
public ZMsg duplicate() {
if (frames != null) {
ZMsg msg = new ZMsg();
for (ZFrame f : frames)
msg.add(f.duplicate());
return msg;
} else
return null;
}
/**
* Push frame plus empty frame to front of message, before 1st frame. Message takes ownership of frame, will destroy
* it when message is sent.
*
* @param frame
*/
public void wrap(ZFrame frame) {
if (frame != null) {
push(new ZFrame(""));
push(frame);
}
}
/**
* Pop frame off front of message, caller now owns frame. If next frame is empty, pops and destroys that empty frame
* (e.g. useful when unwrapping ROUTER socket envelopes)
*
* @return Unwrapped frame
*/
public ZFrame unwrap() {
if (size() == 0)
return null;
ZFrame f = pop();
ZFrame empty = getFirst();
if (empty.hasData() && empty.size() == 0) {
empty = pop();
empty.destroy();
}
return f;
}
/**
* Send message to 0MQ socket.
*
* @param socket 0MQ socket to send ZMsg on.
*/
public void send(Socket socket) {
send(socket, false);
}
/**
* Send message to 0MQ socket, destroys contents after sending if destroy param is set to true. If the message has
* no frames, sends nothing but still destroy()s the ZMsg object
*
* @param socket 0MQ socket to send ZMsg on.
*/
public void send(Socket socket, boolean destroy) {
if (socket == null)
throw new IllegalArgumentException("socket is null");
if (frames.size() == 0)
return;
Iterator i = frames.iterator();
while (i.hasNext()) {
ZFrame f = i.next();
f.sendAndKeep(socket, (i.hasNext()) ? ZMQ.SNDMORE : 0);
}
if (destroy) {
destroy();
}
}
/**
* Receives message from socket, returns ZMsg object or null if the recv was interrupted. Does a blocking recv, if
* you want not to block then use the ZLoop class or ZMQ.Poller to check for socket input before receiving or
* recvMsg with flag ZMQ.DONTWAIT.
*
* @param socket
* @return
*/
public static ZMsg recvMsg(Socket socket) {
return recvMsg(socket, 0);
}
/**
* Receives message from socket, returns ZMsg object or null if the recv was interrupted. Does a blocking recv, if
* you want not to block then use the ZLoop class or ZMQ.Poller to check for socket input before receiving.
*
* @param socket
* @param flag see ZMQ constants
* @return
*/
public static ZMsg recvMsg(Socket socket, int flag) {
if (socket == null)
throw new IllegalArgumentException("socket is null");
ZMsg msg = new ZMsg();
while (true) {
ZFrame f = ZFrame.recvFrame(socket, flag);
if (f == null) {
// If receive failed or was interrupted
msg.destroy();
break;
}
msg.add(f);
if (!f.hasMore())
break;
}
return msg;
}
/**
* Save message to an open data output stream.
*
* Data saved as: 4 bytes: number of frames For every frame: 4 bytes: byte size of frame data + n bytes: frame byte
* data
*
* @param msg ZMsg to save
* @param file DataOutputStream
* @return True if saved OK, else false
*/
public static boolean save(ZMsg msg, DataOutputStream file) {
if (msg == null)
return false;
try {
// Write number of frames
file.writeInt(msg.size());
if (msg.size() > 0) {
for (ZFrame f : msg) {
// Write byte size of frame
file.writeInt(f.size());
// Write frame byte data
file.write(f.getData());
}
}
return true;
} catch (IOException e) {
return false;
}
}
/**
* Load / append a ZMsg from an open DataInputStream
*
* @param file DataInputStream connected to file
* @return ZMsg object
*/
public static ZMsg load(DataInputStream file) {
if (file == null)
return null;
ZMsg rcvMsg = new ZMsg();
try {
int msgSize = file.readInt();
if (msgSize > 0) {
int msgNbr = 0;
while (++msgNbr <= msgSize) {
int frameSize = file.readInt();
byte[] data = new byte[frameSize];
file.read(data);
rcvMsg.add(new ZFrame(data));
}
}
return rcvMsg;
} catch (IOException e) {
return null;
}
}
/**
* Create a new ZMsg from one or more Strings
*
* @param strings Strings to add as frames.
* @return ZMsg object
*/
public static ZMsg newStringMsg(String... strings) {
ZMsg msg = new ZMsg();
for (String data : strings) {
msg.addString(data);
}
return msg;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ZMsg zMsg = (ZMsg) o;
if (frames == null || zMsg.frames == null)
return false;
// based on AbstractList
Iterator e1 = frames.iterator();
Iterator e2 = zMsg.frames.iterator();
while (e1.hasNext() && e2.hasNext()) {
ZFrame o1 = e1.next();
ZFrame o2 = e2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
@Override
public int hashCode() {
if (frames == null || frames.size() == 0)
return 0;
int result = 1;
for (ZFrame frame : frames)
result = 31 * result + (frame == null ? 0 : frame.hashCode());
return result;
}
/**
* Dump the message in human readable format. This should only be used for debugging and tracing, inefficient in
* handling large messages.
**/
public void dump(Appendable out) {
try {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
pw.printf("--------------------------------------\n");
for (ZFrame frame : frames) {
pw.printf("[%03d] %s\n", frame.getData().length, frame.toString());
}
out.append(sw.getBuffer());
sw.close();
} catch (IOException e) {
throw new RuntimeException("Message dump exception " + super.toString(), e);
}
}
/**
* Convert the message to a string, for use in debugging.
*/
public String toString() {
StringBuilder sb = new StringBuilder();
dump(sb);
return sb.toString();
}
// ********* Convenience Deque methods for common data types *** //
public void addFirst(String stringValue) {
addFirst(new ZFrame(stringValue));
}
public void addFirst(byte[] data) {
addFirst(new ZFrame(data));
}
public void addLast(String stringValue) {
addLast(new ZFrame(stringValue));
}
public void addLast(byte[] data) {
addLast(new ZFrame(data));
}
// ********* Convenience Queue methods for common data types *** //
public void push(String str) {
push(new ZFrame(str));
}
public void push(byte[] data) {
push(new ZFrame(data));
}
public boolean add(String stringValue) {
return add(new ZFrame(stringValue));
}
public boolean add(byte[] data) {
return add(new ZFrame(data));
}
// ********* Implement Iterable Interface *************** //
@Override
public Iterator iterator() {
// TODO Auto-generated method stub
return frames.iterator();
}
// ********* Implement Deque Interface ****************** //
@Override
public boolean addAll(Collection arg0) {
return frames.addAll(arg0);
}
@Override
public void clear() {
frames.clear();
}
@Override
public boolean containsAll(Collection arg0) {
return frames.containsAll(arg0);
}
@Override
public boolean isEmpty() {
return frames.isEmpty();
}
@Override
public boolean removeAll(Collection arg0) {
return frames.removeAll(arg0);
}
@Override
public boolean retainAll(Collection arg0) {
return frames.retainAll(arg0);
}
@Override
public Object[] toArray() {
return frames.toArray();
}
@Override
public T[] toArray(T[] arg0) {
return frames.toArray(arg0);
}
@Override
public boolean add(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
return frames.add(e);
}
@Override
public void addFirst(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
frames.addFirst(e);
}
@Override
public void addLast(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
frames.addLast(e);
}
@Override
public boolean contains(Object o) {
return frames.contains(o);
}
@Override
public Iterator descendingIterator() {
return frames.descendingIterator();
}
@Override
public ZFrame element() {
return frames.element();
}
@Override
public ZFrame getFirst() {
try {
return frames.getFirst();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public ZFrame getLast() {
try {
return frames.getLast();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public boolean offer(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
return frames.offer(e);
}
@Override
public boolean offerFirst(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
return frames.offerFirst(e);
}
@Override
public boolean offerLast(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
return frames.offerLast(e);
}
@Override
public ZFrame peek() {
return frames.peek();
}
@Override
public ZFrame peekFirst() {
try {
return frames.peekFirst();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public ZFrame peekLast() {
try {
return frames.peekLast();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public ZFrame poll() {
return frames.poll();
}
@Override
public ZFrame pollFirst() {
return frames.pollFirst();
}
@Override
public ZFrame pollLast() {
return frames.pollLast();
}
@Override
public ZFrame pop() {
if (frames == null)
frames = new ArrayDeque();
try {
return frames.pop();
} catch (NoSuchElementException e) {
return null;
}
}
/**
* Pop a ZFrame and return the toString() representation of it.
*
* @return toString version of pop'ed frame, or null if no frame exists.
*/
public String popString() {
ZFrame frame = pop();
if (frame == null)
return null;
return frame.toString();
}
@Override
public void push(ZFrame e) {
if (frames == null)
frames = new ArrayDeque();
frames.push(e);
}
@Override
public ZFrame remove() {
return frames.remove();
}
@Override
public boolean remove(Object o) {
return frames.remove(o);
}
@Override
public ZFrame removeFirst() {
try {
return frames.removeFirst();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public boolean removeFirstOccurrence(Object o) {
return frames.removeFirstOccurrence(o);
}
@Override
public ZFrame removeLast() {
try {
return frames.removeLast();
} catch (NoSuchElementException e) {
return null;
}
}
@Override
public boolean removeLastOccurrence(Object o) {
return frames.removeLastOccurrence(o);
}
@Override
public int size() {
return frames.size();
}
}
jzmq-3.1.0/src/main/java/org/zeromq/ZThread.java 0000664 0000000 0000000 00000005725 12360016021 0021440 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.zeromq.ZMQ.Socket;
public class ZThread {
public static interface IAttachedRunnable {
public void run(Object[] args, ZContext ctx, Socket pipe);
}
public static interface IDetachedRunnable {
public void run(Object[] args);
}
private static class ShimThread extends Thread {
private ZContext ctx;
private IAttachedRunnable attachedRunnable;
private IDetachedRunnable detachedRunnable;
private Object[] args;
private Socket pipe;
protected ShimThread(ZContext ctx, IAttachedRunnable runnable, Object[] args, Socket pipe) {
assert (ctx != null);
assert (pipe != null);
assert (runnable != null);
this.ctx = ctx;
this.attachedRunnable = runnable;
this.args = args;
this.pipe = pipe;
}
public ShimThread(IDetachedRunnable runnable, Object[] args) {
assert (runnable != null);
this.detachedRunnable = runnable;
this.args = args;
}
@Override
public void run() {
if (attachedRunnable != null) {
try {
attachedRunnable.run(args, ctx, pipe);
} catch (ZMQException e) {
if (e.getErrorCode() != ZMQ.ETERM()) {
throw e;
}
}
ctx.destroy();
} else
detachedRunnable.run(args);
}
}
// --------------------------------------------------------------------------
// Create a detached thread. A detached thread operates autonomously
// and is used to simulate a separate process. It gets no ctx, and no
// pipe.
public static void start(IDetachedRunnable runnable, Object... args) {
// Prepare child thread
Thread shim = new ShimThread(runnable, args);
shim.start();
}
// --------------------------------------------------------------------------
// Create an attached thread. An attached thread gets a ctx and a PAIR
// pipe back to its parent. It must monitor its pipe, and exit if the
// pipe becomes unreadable. Returns pipe, or null if there was an error.
public static Socket fork(ZContext ctx, IAttachedRunnable runnable, Object... args) {
Socket pipe = ctx.createSocket(ZMQ.PAIR);
if (pipe != null) {
pipe.bind(String.format("inproc://zctx-pipe-%d", pipe.hashCode()));
} else {
return null;
}
// Connect child pipe to our pipe
ZContext ccontext = ZContext.shadow(ctx);
Socket cpipe = ccontext.createSocket(ZMQ.PAIR);
if (cpipe == null)
return null;
cpipe.connect(String.format("inproc://zctx-pipe-%d", pipe.hashCode()));
// Prepare child thread
Thread shim = new ShimThread(ccontext, runnable, args, cpipe);
shim.start();
return pipe;
}
}
jzmq-3.1.0/src/main/perf/ 0000775 0000000 0000000 00000000000 12360016021 0015132 5 ustar 00root root 0000000 0000000 jzmq-3.1.0/src/main/perf/Makefile.am 0000664 0000000 0000000 00000000637 12360016021 0017174 0 ustar 00root root 0000000 0000000 jarfile = zmq-perf.jar
jardir = $(datadir)/perf
JZMQ_PERF_JAVA_FILES = \
local_lat.java \
local_thr.java \
remote_lat.java \
remote_thr.java
JZMQ_PERF_CLASS_FILES = *.class
$(jarfile):
$(JAVAC) -classpath $(top_builddir)/src/main/java -d . $(JZMQ_PERF_JAVA_FILES)
$(JAR) cf $(JARFLAGS) $@ $(JZMQ_PERF_CLASS_FILES)
jar_DATA = $(jarfile)
CLEANFILES = \
-rf org \
$(JZMQ_PERF_CLASS_FILES) \
$(jarfile)
jzmq-3.1.0/src/main/perf/local_lat.java 0000664 0000000 0000000 00000003273 12360016021 0017734 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see .
*/
import org.zeromq.ZMQ;
class local_lat
{
public static void main (String [] args)
{
if (args.length != 3) {
System.out.println ("usage: local_lat " +
" ");
return;
}
String bindTo = args [0];
int messageSize = Integer.parseInt (args [1]);
int roundtripCount = Integer.parseInt (args [2]);
ZMQ.Context ctx = ZMQ.context (1);
ZMQ.Socket s = ctx.socket (ZMQ.REP);
// Add your socket options here.
// For example ZMQ_RATE, ZMQ_RECOVERY_IVL and ZMQ_MCAST_LOOP for PGM.
s.bind (bindTo);
for (int i = 0; i != roundtripCount; i++) {
byte [] data = s.recv (0);
assert (data.length == messageSize);
s.send (data, 0);
}
try {
Thread.sleep (1000);
}
catch (InterruptedException e) {
e.printStackTrace ();
}
}
}
jzmq-3.1.0/src/main/perf/local_lat.sh 0000775 0000000 0000000 00000000104 12360016021 0017416 0 ustar 00root root 0000000 0000000 #!/bin/sh
java -classpath "../src/zmq.jar:zmq-perf.jar" local_lat $@ jzmq-3.1.0/src/main/perf/local_thr.java 0000664 0000000 0000000 00000004304 12360016021 0017745 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see .
*/
import org.zeromq.ZMQ;
class local_thr
{
public static void main (String [] args)
{
if (args.length != 3) {
System.out.println ("usage: local_thr " +
" ");
return;
}
String bindTo = args [0];
long messageSize = Integer.parseInt (args [1]);
long messageCount = Integer.parseInt (args [2]);
ZMQ.Context ctx = ZMQ.context (1);
ZMQ.Socket s = ctx.socket (ZMQ.PULL);
// Add your socket options here.
// For example ZMQ_RATE, ZMQ_RECOVERY_IVL and ZMQ_MCAST_LOOP for PGM.
s.bind (bindTo);
byte [] data = s.recv (0);
assert (data.length == messageSize);
long start = System.currentTimeMillis ();
for (int i = 1; i != messageCount; i ++) {
data = s.recv (0);
assert (data.length == messageSize);
}
long end = System.currentTimeMillis ();
long elapsed = (end - start) * 1000;
if (elapsed == 0)
elapsed = 1;
long throughput = messageCount * 1000000 / elapsed;
double megabits = (double) (throughput * messageSize * 8) / 1000000;
System.out.println ("message size: " + messageSize + " [B]");
System.out.println ("message count: " + messageCount);
System.out.println ("mean throughput: " + throughput + "[msg/s]");
System.out.println ("mean throughput: " + megabits + "[Mb/s]");
}
}
jzmq-3.1.0/src/main/perf/local_thr.sh 0000775 0000000 0000000 00000000104 12360016021 0017433 0 ustar 00root root 0000000 0000000 #!/bin/sh
java -classpath "../src/zmq.jar:zmq-perf.jar" local_thr $@ jzmq-3.1.0/src/main/perf/remote_lat.java 0000664 0000000 0000000 00000004001 12360016021 0020123 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see .
*/
import org.zeromq.ZMQ;
class remote_lat
{
public static void main (String [] args)
{
if (args.length != 3) {
System.out.println ("usage: remote_lat " +
" ");
return;
}
String connectTo = args [0];
int messageSize = Integer.parseInt (args [1]);
int roundtripCount = Integer.parseInt (args [2]);
ZMQ.Context ctx = ZMQ.context (1);
ZMQ.Socket s = ctx.socket (ZMQ.REQ);
// Add your socket options here.
// For example ZMQ_RATE, ZMQ_RECOVERY_IVL and ZMQ_MCAST_LOOP for PGM.
s.connect (connectTo);
long start = System.currentTimeMillis ();
byte data [] = new byte [messageSize];
for (int i = 0; i != roundtripCount; i ++) {
s.send (data, 0);
data = s.recv (0);
assert (data.length == messageSize);
}
long end = System.currentTimeMillis ();
long elapsed = (end - start) * 1000;
double latency = (double) elapsed / roundtripCount / 2;
System.out.println ("message size: " + messageSize + " [B]");
System.out.println ("roundtrip count: " + roundtripCount);
System.out.println ("mean latency: " + latency + " [us]");
}
}
jzmq-3.1.0/src/main/perf/remote_lat.sh 0000775 0000000 0000000 00000000105 12360016021 0017620 0 ustar 00root root 0000000 0000000 #!/bin/sh
java -classpath "../src/zmq.jar:zmq-perf.jar" remote_lat $@ jzmq-3.1.0/src/main/perf/remote_thr.java 0000664 0000000 0000000 00000003054 12360016021 0020147 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see .
*/
import org.zeromq.ZMQ;
class remote_thr
{
public static void main (String [] args)
{
if (args.length != 3) {
System.out.println ("usage: remote_thr " +
" ");
return;
}
// Parse the command line arguments.
String connectTo = args [0];
int messageSize = Integer.parseInt (args [1]);
int messageCount = Integer.parseInt (args [2]);
ZMQ.Context ctx = ZMQ.context (1);
ZMQ.Socket s = ctx.socket (ZMQ.PUSH);
// Add your socket options here.
// For example ZMQ_RATE, ZMQ_RECOVERY_IVL and ZMQ_MCAST_LOOP for PGM.
s.connect (connectTo);
byte msg [] = new byte [messageSize];
for (int i = 0; i != messageCount; i++)
s.send (msg, 0);
}
}
jzmq-3.1.0/src/main/perf/remote_thr.sh 0000775 0000000 0000000 00000000105 12360016021 0017635 0 ustar 00root root 0000000 0000000 #!/bin/sh
java -classpath "../src/zmq.jar:zmq-perf.jar" remote_thr $@ jzmq-3.1.0/src/test/ 0000775 0000000 0000000 00000000000 12360016021 0014231 5 ustar 00root root 0000000 0000000 jzmq-3.1.0/src/test/java/ 0000775 0000000 0000000 00000000000 12360016021 0015152 5 ustar 00root root 0000000 0000000 jzmq-3.1.0/src/test/java/org/ 0000775 0000000 0000000 00000000000 12360016021 0015741 5 ustar 00root root 0000000 0000000 jzmq-3.1.0/src/test/java/org/zeromq/ 0000775 0000000 0000000 00000000000 12360016021 0017256 5 ustar 00root root 0000000 0000000 jzmq-3.1.0/src/test/java/org/zeromq/ZContextTest.java 0000664 0000000 0000000 00000005027 12360016021 0022543 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.junit.Test;
import org.zeromq.ZMQ.Socket;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Tests high-level ZContext class
*
* @author richardsmith
*
*/
public class ZContextTest {
@Test
public void testConstruction() {
ZContext ctx = new ZContext();
assertTrue(ctx != null);
assertEquals(1, ctx.getIoThreads());
assertEquals(0, ctx.getLinger());
assertTrue(ctx.isMain());
}
@Test
public void testDestruction() {
ZContext ctx = new ZContext();
ctx.destroy();
assertTrue(ctx.getSockets().isEmpty());
// Ensure context is not destroyed if not in main thread
ZContext ctx1 = new ZContext();
ctx1.setMain(false);
@SuppressWarnings("unused")
Socket s = ctx1.createSocket(ZMQ.PAIR);
ctx1.destroy();
assertTrue(ctx1.getSockets().isEmpty());
assertTrue(ctx1.getContext() != null);
}
@Test
public void testAddingSockets() throws ZMQException {
// Tests "internal" newSocket method, should not be used outside jzmq itself.
ZContext ctx = new ZContext();
try {
Socket s = ctx.createSocket(ZMQ.PUB);
assertTrue(s != null);
assertTrue(s.getType() == ZMQ.PUB);
Socket s1 = ctx.createSocket(ZMQ.REQ);
assertTrue(s1 != null);
assertEquals(2, ctx.getSockets().size());
} finally {
ctx.destroy();
}
}
@Test
public void testRemovingSockets() throws ZMQException {
ZContext ctx = new ZContext();
try {
Socket s = ctx.createSocket(ZMQ.PUB);
assertTrue(s != null);
assertEquals(1, ctx.getSockets().size());
ctx.destroySocket(s);
assertEquals(0, ctx.getSockets().size());
} finally {
ctx.destroy();
}
}
@Test
public void testShadow() {
ZContext ctx = new ZContext();
Socket s = ctx.createSocket(ZMQ.PUB);
assertTrue(s != null);
assertEquals(1, ctx.getSockets().size());
ZContext shadowCtx = ZContext.shadow(ctx);
shadowCtx.setMain(false);
assertEquals(0, shadowCtx.getSockets().size());
@SuppressWarnings("unused")
Socket s1 = shadowCtx.createSocket(ZMQ.SUB);
assertEquals(1, shadowCtx.getSockets().size());
assertEquals(1, ctx.getSockets().size());
shadowCtx.destroy();
ctx.destroy();
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZDispatcherTest.java 0000664 0000000 0000000 00000017515 12360016021 0023212 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.junit.Test;
import java.text.MessageFormat;
import java.util.UUID;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
/**
*/
public class ZDispatcherTest {
@Test
public void singleMessage() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
ZContext ctx = new ZContext();
ZMQ.Socket logger = ctx.createSocket(ZMQ.PAIR);
logger.bind("inproc://zmsg.test");
ZMQ.Socket out = ctx.createSocket(ZMQ.PAIR);
out.connect("inproc://zmsg.test");
final String mesgTxt = "Hello";
ZDispatcher dispatcher = new ZDispatcher();
ZDispatcher.ZSender outSender = new ZDispatcher.ZSender();
dispatcher.registerHandler(out, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
}
}, outSender);
dispatcher.registerHandler(logger, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
assertEquals(mesgTxt, msg.poll().toString());
latch.countDown();
}
}, new ZDispatcher.ZSender());
ZMsg msg = new ZMsg();
ZFrame frame = new ZFrame(mesgTxt);
msg.addFirst(frame);
outSender.send(msg);
latch.await(1, TimeUnit.SECONDS);
assertEquals(0, latch.getCount());
dispatcher.shutdown();
ctx.destroy();
}
@Test
public void testMessagesDispatchedToDifferentHandlersAreExecutedConcurrently() throws InterruptedException, BrokenBarrierException, TimeoutException {
final AtomicBoolean threadingIssueDetected = new AtomicBoolean(false);
final Lock guardLock1 = new ReentrantLock();
final Lock guardLock2 = new ReentrantLock();
final CyclicBarrier handlersBarrier = new CyclicBarrier(3);
ZContext ctx = new ZContext();
ZMQ.Socket socketOne = ctx.createSocket(ZMQ.PAIR);
socketOne.bind("inproc://zmsg.test");
ZMQ.Socket socketTwo = ctx.createSocket(ZMQ.PAIR);
socketTwo.connect("inproc://zmsg.test");
ZDispatcher dispatcher = new ZDispatcher();
ZDispatcher.ZSender senderOne = new ZDispatcher.ZSender();
dispatcher.registerHandler(socketOne, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
try {
if (guardLock1.tryLock()) {
handlersBarrier.await(1, TimeUnit.SECONDS);
} else {
threadingIssueDetected.set(true);
}
} catch (Exception ex) {
threadingIssueDetected.set(true);
} finally {
guardLock1.unlock();
}
}
}, senderOne);
ZDispatcher.ZSender senderTwo = new ZDispatcher.ZSender();
dispatcher.registerHandler(socketTwo, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
try {
if (guardLock2.tryLock()) {
handlersBarrier.await(1, TimeUnit.SECONDS);
} else {
threadingIssueDetected.set(true);
}
} catch (Exception ex) {
threadingIssueDetected.set(true);
} finally {
guardLock2.unlock();
}
}
}, senderTwo);
ZMsg msg = new ZMsg();
ZFrame frame = new ZFrame("Hello");
msg.addFirst(frame);
senderOne.send(msg.duplicate());
senderOne.send(msg.duplicate());
senderTwo.send(msg.duplicate());
senderTwo.send(msg.duplicate());
handlersBarrier.await(1, TimeUnit.SECONDS);
handlersBarrier.await(1, TimeUnit.SECONDS);
assertFalse(threadingIssueDetected.get());
dispatcher.shutdown();
ctx.destroy();
}
@Test
public void testNoMessageAreSentAfterShutdown() throws InterruptedException, BrokenBarrierException, TimeoutException {
final AtomicBoolean shutdownIssueDetected = new AtomicBoolean(false);
final CountDownLatch latch = new CountDownLatch(1);
ZContext ctx = new ZContext();
ZMQ.Socket socketOne = ctx.createSocket(ZMQ.PAIR);
socketOne.bind("inproc://zmsg.test");
ZMQ.Socket socketTwo = ctx.createSocket(ZMQ.PAIR);
socketTwo.connect("inproc://zmsg.test");
final ZDispatcher dispatcher = new ZDispatcher();
final CyclicBarrier handlersBarrier = new CyclicBarrier(2, new Runnable() {
@Override
public void run() {
if (latch.getCount() == 0) {
dispatcher.shutdown();
}
}
});
ZDispatcher.ZSender senderOne = new ZDispatcher.ZSender();
dispatcher.registerHandler(socketOne, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
latch.countDown();
try {
handlersBarrier.await(1, TimeUnit.SECONDS);
} catch (Exception e) {
}
}
}, senderOne);
ZDispatcher.ZSender senderTwo = new ZDispatcher.ZSender();
dispatcher.registerHandler(socketTwo, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
sender.send(msg);
shutdownIssueDetected.set(true);
}
}, senderTwo);
ZMsg msg = new ZMsg();
msg.add(new ZFrame("Hello"));
senderTwo.send(msg);
handlersBarrier.await(1, TimeUnit.SECONDS);
senderOne.send(msg);
senderOne.send(msg);
latch.await(1, TimeUnit.SECONDS);
assertEquals(0, latch.getCount());
assertFalse(shutdownIssueDetected.get());
dispatcher.shutdown();
ctx.destroy();
}
@Test
public void dispatcherPerformanceTest() throws InterruptedException {
final int nMessages = 1000000;
final CountDownLatch latch = new CountDownLatch(nMessages);
ZContext ctx = new ZContext();
ZDispatcher dispatcher = new ZDispatcher();
ZMQ.Socket in = ctx.createSocket(ZMQ.ROUTER);
in.bind("inproc://zmsg.test");
ZMQ.Socket out = ctx.createSocket(ZMQ.DEALER);
out.connect("inproc://zmsg.test");
dispatcher.registerHandler(in, new ZDispatcher.ZMessageHandler() {
@Override
public void handleMessage(ZDispatcher.ZSender sender, ZMsg msg) {
latch.countDown();
}
}, new ZDispatcher.ZSender());
long start = System.currentTimeMillis();
for (int i = 0; i < nMessages; i++) {
ZMsg msg = new ZMsg();
msg.addLast(UUID.randomUUID().toString());
msg.send(out);
}
System.out.println(MessageFormat.format("performanceTest message sent:{0}", nMessages));
latch.await();
System.out.println(MessageFormat.format("performanceTest throughput:{0} messages/seconds", nMessages / ((System.currentTimeMillis() - start) / 1000)));
dispatcher.shutdown();
ctx.destroy();
}
} jzmq-3.1.0/src/test/java/org/zeromq/ZFrameTest.java 0000664 0000000 0000000 00000007525 12360016021 0022156 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.junit.Test;
import org.zeromq.ZMQ.Socket;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Tests ZFrame class
*
* @author Richard Smith
*
*/
public class ZFrameTest {
@Test
public void testZFrameCreation() {
ZFrame f = new ZFrame("Hello".getBytes());
assertTrue(f != null);
assertTrue(f.hasData());
assertEquals(5, f.size());
f = new ZFrame();
assertFalse(f.hasData());
assertEquals(0, f.size());
}
@Test
public void testZFrameEquals() {
ZFrame f = new ZFrame("Hello".getBytes());
ZFrame clone = f.duplicate();
assertEquals(f, clone);
}
@Test
public void testSending() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zframe.test");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zframe.test");
// Send five different frames, test ZFRAME_MORE
for (int i = 0; i < 5; i++) {
ZFrame f = new ZFrame("Hello".getBytes());
f.sendAndDestroy(output, ZMQ.SNDMORE);
assertEquals(0, f.size());
}
// Send same frame five times
ZFrame f = new ZFrame("Hello".getBytes());
for (int i = 0; i < 5; i++) {
f.sendAndKeep(output, ZMQ.SNDMORE);
}
assertEquals(5, f.size());
ctx.destroy();
}
@Test
public void testCopyingAndDuplicating() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zframe.test");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zframe.test");
ZFrame f = new ZFrame("Hello".getBytes());
ZFrame copy = f.duplicate();
assertTrue(copy.hasSameData(f));
f.destroy();
assertFalse(copy.hasSameData(f));
assertEquals(5, copy.size());
copy.destroy();
assertFalse(copy.hasSameData(f));
ctx.destroy();
}
@Test
public void testReceiving() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zframe.test");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zframe.test");
// Send same frame five times
ZFrame f = new ZFrame("Hello".getBytes());
for (int i = 0; i < 5; i++) {
f.sendAndKeep(output, ZMQ.SNDMORE);
}
// Send END frame
f = new ZFrame("NOT".getBytes());
f.reset("END".getBytes());
assertEquals("454E44", f.strhex());
f.sendAndDestroy(output);
// Read and count until we receive END
int frame_nbr = 0;
while (true) {
f = ZFrame.recvFrame(input);
frame_nbr++;
if (f.streq("END")) {
f.destroy();
break;
}
}
assertEquals(6, frame_nbr);
f = ZFrame.recvFrame(input, ZMQ.DONTWAIT);
assertTrue(!f.hasData());
ctx.destroy();
}
@Test
public void testStringFrames() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zframe.test");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zframe.test");
ZFrame f1 = new ZFrame("Hello");
assertEquals(5, f1.getData().length);
f1.sendAndKeep(output);
ZFrame f2 = ZFrame.recvFrame(input);
assertTrue(f2.hasData());
assertEquals(5, f2.getData().length);
assertTrue(f2.streq("Hello"));
assertEquals(f2.toString(), "Hello");
assertTrue(f2.hasSameData(f1));
ctx.destroy();
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZLoopTest.java 0000664 0000000 0000000 00000017207 12360016021 0022033 0 ustar 00root root 0000000 0000000 /*
Copyright other contributors as noted in the AUTHORS file.
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see .
*/
package org.zeromq;
import org.junit.After;
import org.junit.Assert;
import org.zeromq.ZMQ.Poller;
import org.zeromq.ZMQ.Socket;
import org.zeromq.ZMQ.PollItem;
import org.junit.Test;
import org.junit.Before;
public class ZLoopTest {
private String received;
private ZContext ctx;
private Socket input;
private Socket output;
@Before
public void setUp() {
ctx = new ZContext();
assert (ctx != null);
output = ctx.createSocket(ZMQ.PAIR);
assert (output != null);
output.bind("inproc://zloop.test");
input = ctx.createSocket(ZMQ.PAIR);
assert (input != null);
input.connect("inproc://zloop.test");
received = "FAILED";
}
@After
public void tearDown() {
ctx.destroy();
}
@Test
public void testZLoop() {
int rc = 0;
ZLoop loop = new ZLoop();
assert (loop != null);
ZLoop.IZLoopHandler timerEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
((Socket) arg).send("PING", 0);
return 0;
}
};
ZLoop.IZLoopHandler socketEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
received = ((Socket) arg).recvStr(0);
// Just end the reactor
return -1;
}
};
// After 10 msecs, send a ping message to output
loop.addTimer(10, 1, timerEvent, input);
// When we get the ping message, end the reactor
PollItem pollInput = new PollItem(output, Poller.POLLIN);
rc = loop.addPoller(pollInput, socketEvent, output);
Assert.assertEquals(0, rc);
loop.start();
loop.removePoller(pollInput);
Assert.assertEquals("PING", received);
}
@Test
public void testZLoopAddTimerFromTimer() {
int rc = 0;
ZLoop loop = new ZLoop();
assert (loop != null);
ZLoop.IZLoopHandler timerEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
final long now = System.currentTimeMillis();
ZLoop.IZLoopHandler timerEvent2 = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
final long now2 = System.currentTimeMillis();
assert (now2 >= now + 10);
((Socket) arg).send("PING", 0);
return 0;
}
};
loop.addTimer(10, 1, timerEvent2, arg);
return 0;
}
};
ZLoop.IZLoopHandler socketEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
received = ((Socket) arg).recvStr(0);
// Just end the reactor
return -1;
}
};
// After 10 msecs, fire a timer that registers
// another timer that sends the ping message
loop.addTimer(10, 1, timerEvent, input);
// When we get the ping message, end the reactor
PollItem pollInput = new PollItem(output, Poller.POLLIN);
rc = loop.addPoller(pollInput, socketEvent, output);
Assert.assertEquals(0, rc);
loop.start();
loop.removePoller(pollInput);
Assert.assertEquals("PING", received);
}
@Test(timeout = 1000)
public void testZLoopAddTimerFromSocketHandler() {
int rc = 0;
ZLoop loop = new ZLoop();
assert (loop != null);
ZLoop.IZLoopHandler timerEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
((Socket) arg).send("PING", 0);
return 0;
}
};
ZLoop.IZLoopHandler socketEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
final long now = System.currentTimeMillis();
ZLoop.IZLoopHandler timerEvent2 = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
final long now2 = System.currentTimeMillis();
Assert.assertTrue(now2 >= now + 10);
received = ((Socket) arg).recvStr(0);
// Just end the reactor
return -1;
}
};
// After 10 msec fire a timer that ends the reactor
loop.addTimer(10, 1, timerEvent2, arg);
return 0;
}
};
// Fire a timer that sends the ping message
loop.addTimer(0, 1, timerEvent, input);
// When we get the ping message, end the reactor
PollItem pollInput = new PollItem(output, Poller.POLLIN);
rc = loop.addPoller(pollInput, socketEvent, output);
Assert.assertEquals(0, rc);
loop.start();
loop.removePoller(pollInput);
Assert.assertEquals("PING", received);
}
@Test(timeout = 1000)
public void testZLoopEndReactorFromTimer() {
int rc = 0;
ZLoop loop = new ZLoop();
assert (loop != null);
ZLoop.IZLoopHandler timerEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
((Socket) arg).send("PING", 0);
return 0;
}
};
ZLoop.IZLoopHandler socketEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
// After 10 msecs, fire an event that ends the reactor
ZLoop.IZLoopHandler shutdownEvent = new ZLoop.IZLoopHandler() {
@Override
public int handle(ZLoop loop, PollItem item, Object arg) {
received = ((Socket) arg).recvStr(0);
// Just end the reactor
return -1;
}
};
loop.addTimer(10, 1, shutdownEvent, arg);
return 0;
}
};
// Fire event that sends a ping message to output
loop.addTimer(0, 1, timerEvent, input);
// When we get the ping message, end the reactor
PollItem pollInput = new PollItem(output, Poller.POLLIN);
rc = loop.addPoller(pollInput, socketEvent, output);
Assert.assertEquals(0, rc);
loop.start();
loop.removePoller(pollInput);
Assert.assertEquals("PING", received);
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZMQForwarderTest.java 0000664 0000000 0000000 00000002023 12360016021 0023301 0 ustar 00root root 0000000 0000000 package org.zeromq;
import static org.junit.Assert.assertArrayEquals;
import org.junit.Test;
public class ZMQForwarderTest {
@Test
public void testQueue() throws InterruptedException {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket clients = context.socket(ZMQ.PAIR);
clients.bind("inproc://fw_clients");
ZMQ.Socket client = context.socket(ZMQ.PAIR);
client.connect("inproc://fw_clients");
ZMQ.Socket workers = context.socket(ZMQ.PAIR);
workers.bind("inproc://fw_workers");
ZMQ.Socket worker = context.socket(ZMQ.PAIR);
worker.connect("inproc://fw_workers");
Thread t = new Thread(new ZMQForwarder(context, clients, workers));
t.start();
for (int i = 0; i < 10; i++) {
byte[] req = ("request" + i).getBytes();
client.send(req, 0);
// worker receives request
byte[] reqTmp = worker.recv(0);
assertArrayEquals(req, reqTmp);
}
t.interrupt();
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZMQQueueTest.java 0000664 0000000 0000000 00000002122 12360016021 0022432 0 ustar 00root root 0000000 0000000 package org.zeromq;
import static org.junit.Assert.assertArrayEquals;
import org.junit.Test;
public class ZMQQueueTest {
@Test
public void testQueue() throws InterruptedException {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket clients = context.socket(ZMQ.XREP);
clients.bind("inproc://gate_clients");
ZMQ.Socket workers = context.socket(ZMQ.XREQ);
workers.bind("inproc://gate_workers");
ZMQ.Socket client = context.socket(ZMQ.REQ);
client.connect("inproc://gate_clients");
ZMQ.Socket worker = context.socket(ZMQ.REP);
worker.connect("inproc://gate_workers");
Thread t = new Thread(new ZMQQueue(context, clients, workers));
t.start();
for (int i = 0; i < 10; i++) {
byte[] req = ("request" + i).getBytes();
byte[] rsp = ("response" + i).getBytes();
client.send(req, 0);
// worker receives request
byte[] reqTmp = worker.recv(0);
assertArrayEquals(req, reqTmp);
// worker sends response
worker.send(rsp, 0);
// client receives response
byte[] rspTmp = client.recv(0);
assertArrayEquals(rsp, rspTmp);
}
t.interrupt();
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZMQTest.java 0000664 0000000 0000000 00000063344 12360016021 0021442 0 ustar 00root root 0000000 0000000 package org.zeromq;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.CharacterCodingException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Event;
import org.zeromq.ZMQ.Poller;
import org.zeromq.ZMQ.Socket;
/**
* @author Cliff Evans
*/
public class ZMQTest {
/**
* Test method for {@link org.zeromq.ZMQ#makeVersion(int, int, int)}.
*/
@Test
public void testMakeVersion() {
assertEquals(ZMQ.getFullVersion(),
ZMQ.makeVersion(ZMQ.getMajorVersion(), ZMQ.getMinorVersion(), ZMQ.getPatchVersion()));
}
/**
* Test method for {@link org.zeromq.ZMQ#getVersionString()}.
*/
@Test
public void testGetVersion() {
assertEquals(ZMQ.getMajorVersion() + "." + ZMQ.getMinorVersion() + "." + ZMQ.getPatchVersion(),
ZMQ.getVersionString());
}
/**
* Test method for {@link org.zeromq.ZMQ.Socket#bindToRandomPort(String)}.
*/
@Test
public void testBindToRandomPort() {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket sock = context.socket(ZMQ.DEALER);
// Check that bindToRandomport generate valid port number
for (int i = 0; i < 100; i++) {
sock.bindToRandomPort("tcp://127.0.0.1");
}
sock.close();
sock = context.socket(ZMQ.DEALER);
// Check that exception different of EADDRINUSE is not catched
// Invalid protocol
try {
sock.bindToRandomPort("noprotocol://127.0.0.1");
} catch (ZMQException e) {
assertEquals(e.getErrorCode(), ZMQ.EPROTONOSUPPORT());
}
}
@Test
public void testReqRep() {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket in = context.socket(ZMQ.REQ);
in.bind("inproc://reqrep");
ZMQ.Socket out = context.socket(ZMQ.REP);
out.connect("inproc://reqrep");
for (int i = 0; i < 10; i++) {
byte[] req = ("request" + i).getBytes();
byte[] rep = ("reply" + i).getBytes();
assertTrue(in.send(req, 0));
byte[] reqTmp = out.recv(0);
assertArrayEquals(req, reqTmp);
assertTrue(out.send(rep, 0));
byte[] repTmp = in.recv(0);
assertArrayEquals(rep, repTmp);
}
}
@Test
public void testXPUBSUB() {
if (ZMQ.getFullVersion() < ZMQ.make_version(3, 0, 0)) {
// Can only test XPUB on ZMQ >= of 3.0
return;
}
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket pub = context.socket(ZMQ.XPUB);
pub.bind("inproc://xpub");
ZMQ.Socket sub = context.socket(ZMQ.SUB);
sub.connect("inproc://xpub");
ZMQ.Socket xsub = context.socket(ZMQ.XSUB);
xsub.connect("inproc://xpub");
sub.subscribe("".getBytes());
byte[] subcr = pub.recv(0);
assertArrayEquals(new byte[] { 1 }, subcr);
sub.unsubscribe("".getBytes());
subcr = pub.recv(0);
assertArrayEquals(new byte[] { 0 }, subcr);
byte[] subscription = "subs".getBytes();
// Append subscription
byte[] expected = new byte[subscription.length + 1];
expected[0] = 1;
System.arraycopy(subscription, 0, expected, 1, subscription.length);
sub.subscribe(subscription);
subcr = pub.recv(0);
assertArrayEquals(expected, subcr);
// Verify xsub subscription
xsub.send(expected, 0);
subcr = pub.recv(1);
assertNull(subcr);
for (int i = 0; i < 10; i++) {
byte[] data = ("subscrip" + i).getBytes();
assertTrue(pub.send(data, 0));
// Verify SUB
byte[] tmp = sub.recv(0);
assertArrayEquals(data, tmp);
// Verify XSUB
tmp = xsub.recv(0);
assertArrayEquals(data, tmp);
}
}
@Test
public void testSetXpubVerbose() {
if (ZMQ.getFullVersion() < ZMQ.make_version(3, 2, 2)) {
// Can only test ZMQ_XPUB_VERBOSE on ZMQ >= of 3.2.2
return;
}
ZMQ.Context context = ZMQ.context(1);
byte[] topic = "topic".getBytes();
byte[] subscription = new byte[topic.length + 1];
subscription[0] = 1;
System.arraycopy(topic, 0, subscription, 1, topic.length);
ZMQ.Socket xpubVerbose = context.socket(ZMQ.XPUB);
xpubVerbose.setXpubVerbose(true);
xpubVerbose.bind("inproc://xpub_verbose");
ZMQ.Socket xpubDefault = context.socket(ZMQ.XPUB);
xpubDefault.bind("inproc://xpub_default");
ZMQ.Socket[] xsubs = new ZMQ.Socket[3];
for (int i = 0; i < xsubs.length; i++) {
xsubs[i] = context.socket(ZMQ.XSUB);
xsubs[i].connect("inproc://xpub_verbose");
xsubs[i].connect("inproc://xpub_default");
}
for (int i = 0; i < xsubs.length; i++) {
xsubs[i].send(subscription, 0);
assertArrayEquals(subscription, xpubVerbose.recv(0));
if (i == 0) {
assertArrayEquals(subscription, xpubDefault.recv(0));
}
else {
assertNull(xpubDefault.recv(ZMQ.DONTWAIT));
}
}
for (int i = 0; i < xsubs.length; i++) {
xsubs[i].close();
}
xpubVerbose.close();
xpubDefault.close();
context.term();
}
/**
* Test method for various set/get options.
*/
@Test
public void testSetOption() {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket sock = context.socket(ZMQ.REQ);
if (ZMQ.getFullVersion() >= ZMQ.makeVersion(3, 2, 0)) {
sock.setIPv4Only(false);
assertEquals(false, sock.getIPv4Only());
sock.setIPv4Only(true);
assertEquals(true, sock.getIPv4Only());
}
sock.close();
context.term();
}
static class Client extends Thread {
private Socket s = null;
private String name = null;
public Client(Context ctx, String name_) {
s = ctx.socket(ZMQ.REQ);
name = name_;
s.setIdentity(name.getBytes());
}
@Override
public void run() {
s.connect("tcp://127.0.0.1:6660");
s.send("hello", 0);
String msg = s.recvStr(0);
s.send("world", 0);
msg = s.recvStr(0);
s.close();
}
}
static class Dealer extends Thread {
private Socket s = null;
private String name = null;
public Dealer(Context ctx, String name_) {
s = ctx.socket(ZMQ.DEALER);
name = name_;
s.setIdentity(name.getBytes());
}
@Override
public void run() {
s.connect("tcp://127.0.0.1:6661");
int count = 0;
while (count < 2) {
String msg = s.recvStr(0);
if (msg == null) {
throw new RuntimeException();
}
String identity = msg;
msg = s.recvStr(0);
if (msg == null) {
throw new RuntimeException();
}
msg = s.recvStr(0);
if (msg == null) {
throw new RuntimeException();
}
s.send(identity, ZMQ.SNDMORE);
s.send("", ZMQ.SNDMORE);
String response = "OK " + msg;
s.send(response, 0);
count++;
}
s.close();
}
}
static class Main extends Thread {
Context ctx;
Main(Context ctx_) {
ctx = ctx_;
}
@Override
public void run() {
Socket frontend = ctx.socket(ZMQ.ROUTER);
assertNotNull(frontend);
frontend.bind("tcp://127.0.0.1:6660");
Socket backend = ctx.socket(ZMQ.DEALER);
assertNotNull(backend);
backend.bind("tcp://127.0.0.1:6661");
ZMQ.proxy(frontend, backend, null);
frontend.close();
backend.close();
}
}
@Test
public void testProxy() throws Exception {
if (ZMQ.getFullVersion() < ZMQ.make_version(3, 2, 2)) {
// Can only test zmq_proxy on ZMQ >= of 3.2.2
return;
}
Context ctx = ZMQ.context(1);
assert (ctx != null);
Main mt = new Main(ctx);
mt.start();
new Dealer(ctx, "AA").start();
new Dealer(ctx, "BB").start();
Thread.sleep(1000);
Thread c1 = new Client(ctx, "X");
c1.start();
Thread c2 = new Client(ctx, "Y");
c2.start();
c1.join();
c2.join();
ctx.term();
}
/**
* Test method for Router Mandatory
*/
@Test
public void testRouterMandatory() {
if (ZMQ.getFullVersion() < ZMQ.makeVersion(3, 2, 0))
return;
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket sock = context.socket(ZMQ.ROUTER);
boolean ret = sock.sendMore("UNREACHABLE");
assertEquals(true, ret);
sock.send("END");
sock.setRouterMandatory(true);
try {
sock.sendMore("UNREACHABLE");
assertFalse(true);
} catch (ZMQException e) {
assertEquals(ZMQ.EHOSTUNREACH(), e.getErrorCode());
}
sock.close();
context.term();
}
@Test
public void testSendMoreRequestReplyOverTcp() {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket reply = null;
ZMQ.Socket socket = null;
try {
reply = context.socket(ZMQ.REP);
reply.bind("tcp://*:12345");
socket = context.socket(ZMQ.REQ);
socket.connect("tcp://localhost:12345");
socket.send("test1", ZMQ.SNDMORE);
socket.send("test2");
assertEquals("test1", reply.recvStr());
assertTrue(reply.hasReceiveMore());
assertEquals("test2", reply.recvStr());
} finally {
try {
socket.close();
} catch (Exception ignore){}
try {
reply.close();
} catch (Exception ignore){}
try {
context.term();
} catch (Exception ignore) {}
}
}
@Test
public void testWritingToClosedSocket() {
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket sock = null;
try {
sock = context.socket(ZMQ.REQ);
sock.connect("ipc:///tmp/hai");
sock.close();
sock.send("PING".getBytes(), 0);
} catch (ZMQException e) {
assertEquals(ZMQ.ENOTSOCK(), e.getErrorCode());
} finally {
try {
sock.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
@Test
public void testZeroCopyRecv() {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0)) {
ZMQ.Context context = ZMQ.context(1);
ByteBuffer response = ByteBuffer.allocateDirect(1024).order(ByteOrder.nativeOrder());
ZMQ.Socket push = null;
ZMQ.Socket pull = null;
try {
push = context.socket(ZMQ.PUSH);
pull = context.socket(ZMQ.PULL);
pull.bind("tcp://*:45324");
push.connect("tcp://localhost:45324");
push.send("PING");
int rc = pull.recvZeroCopy(response, 16, 0);
response.flip();
byte[] b = new byte[rc];
response.get(b);
assertEquals("PING", new String(b));
} finally {
try {
push.close();
} catch (Exception ignore) {
}
try {
pull.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
}
@Test
public void testZeroCopySend() throws InterruptedException {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0)) {
ZMQ.Context context = ZMQ.context(1);
ByteBuffer bb = ByteBuffer.allocateDirect(1024).order(ByteOrder.nativeOrder());
ZMQ.Socket push = null;
ZMQ.Socket pull = null;
try {
push = context.socket(ZMQ.PUSH);
pull = context.socket(ZMQ.PULL);
pull.bind("tcp://*:45324");
push.connect("tcp://localhost:45324");
bb.put("PING".getBytes());
push.sendZeroCopy(bb, bb.position(), 0);
assertEquals("PING", new String(pull.recv()));
} finally {
try {
push.close();
} catch (Exception ignore) {
}
try {
pull.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
}
@Test
public void testByteBufferSend() throws InterruptedException {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0)) {
ZMQ.Context context = ZMQ.context(1);
ByteBuffer bb = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder());
ZMQ.Socket push = null;
ZMQ.Socket pull = null;
try {
push = context.socket(ZMQ.PUSH);
pull = context.socket(ZMQ.PULL);
pull.bind("ipc:///tmp/sendbb");
push.connect("ipc:///tmp/sendbb");
bb.put("PING".getBytes());
bb.flip();
push.sendByteBuffer(bb, 0);
String actual = new String(pull.recv());
System.out.println(actual);
assertEquals("PING", actual);
} finally {
try {
push.close();
} catch (Exception ignore) {
}
try {
pull.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
}
@Test
public void testByteBufferRecv() throws InterruptedException, CharacterCodingException {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0)) {
ZMQ.Context context = ZMQ.context(1);
ByteBuffer bb = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder());
ZMQ.Socket push = null;
ZMQ.Socket pull = null;
try {
push = context.socket(ZMQ.PUSH);
pull = context.socket(ZMQ.PULL);
pull.bind("ipc:///tmp/recvbb");
push.connect("ipc:///tmp/recvbb");
push.send("PING".getBytes(), 0);
pull.recvByteBuffer(bb, 0);
bb.flip();
byte[] b = new byte[4];
bb.get(b);
assertEquals("PING", new String(b));
} finally {
try {
push.close();
} catch (Exception ignore) {
}
try {
pull.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
}
@Test
public void testByteBufferRecvTooLarge() throws InterruptedException, CharacterCodingException {
if (ZMQ.version_full() >= ZMQ.make_version(3, 0, 0)) {
ZMQ.Context context = ZMQ.context(1);
ByteBuffer bb = ByteBuffer.allocateDirect(5).order(ByteOrder.nativeOrder());
ZMQ.Socket push = null;
ZMQ.Socket pull = null;
try {
push = context.socket(ZMQ.PUSH);
pull = context.socket(ZMQ.PULL);
pull.bind("tcp://*:6787");
push.connect("tcp://127.0.0.1:6787");
push.send("helloworld".getBytes(), 0);
int size = pull.recvByteBuffer(bb, 0);
bb.flip();
byte[] b = new byte[size];
bb.get(b);
assertEquals("hello", new String(b));
} finally {
try {
push.close();
} catch (Exception ignore) {
}
try {
pull.close();
} catch (Exception ignore) {
}
try {
context.term();
} catch (Exception ignore) {
}
}
}
}
@Test
public void testPollerUnregister() {
Context context = ZMQ.context(1);
Socket socketOne = context.socket(ZMQ.SUB);
Socket socketTwo = context.socket(ZMQ.REP);
Poller poller = new ZMQ.Poller(2);
poller.register(socketOne, ZMQ.Poller.POLLIN);
poller.register(socketTwo, ZMQ.Poller.POLLIN);
socketOne.setLinger(0);
socketOne.close();
socketTwo.setLinger(0);
socketTwo.close();
poller.unregister(socketOne);
poller.unregister(socketTwo);
context.term();
}
@Test
public void testEventConnected() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket helper = context.socket(ZMQ.REQ);
int port = helper.bindToRandomPort("tcp://127.0.0.1");
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_CONNECTED));
monitor.connect("inproc://monitor.socket");
socket.connect("tcp://127.0.0.1:" + port);
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_CONNECTED, event.getEvent());
helper.close();
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventConnectDelayed() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_CONNECT_DELAYED));
monitor.connect("inproc://monitor.socket");
socket.connect("tcp://127.0.0.1:6751");
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_CONNECT_DELAYED, event.getEvent());
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventConnectRetried() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_CONNECT_RETRIED));
monitor.connect("inproc://monitor.socket");
socket.connect("tcp://127.0.0.1:6752");
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_CONNECT_RETRIED, event.getEvent());
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventListening() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_LISTENING));
monitor.connect("inproc://monitor.socket");
socket.bindToRandomPort("tcp://127.0.0.1");
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_LISTENING, event.getEvent());
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventBindFailed() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
ZMQ.Event event;
Socket helper = context.socket(ZMQ.REP);
int port = helper.bindToRandomPort("tcp://127.0.0.1");
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_BIND_FAILED));
monitor.connect("inproc://monitor.socket");
try {
socket.bind("tcp://127.0.0.1:" + port);
} catch (ZMQException ex) {}
event = ZMQ.Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_BIND_FAILED, event.getEvent());
helper.close();
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventAccepted() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
Socket helper = context.socket(ZMQ.REQ);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_ACCEPTED));
monitor.connect("inproc://monitor.socket");
int port = socket.bindToRandomPort("tcp://127.0.0.1");
helper.connect("tcp://127.0.0.1:" + port);
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_ACCEPTED, event.getEvent());
helper.close();
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventClosed() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
socket.bindToRandomPort("tcp://127.0.0.1");
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_CLOSED));
monitor.connect("inproc://monitor.socket");
socket.close();
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_CLOSED, event.getEvent());
monitor.close();
context.term();
}
@Test
public void testEventDisconnected() {
if (ZMQ.version_full() < ZMQ.make_version(3, 2, 2)) // Monitor added in 3.2.2
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
Socket helper = context.socket(ZMQ.REQ);
monitor.setReceiveTimeOut(100);
int port = socket.bindToRandomPort("tcp://127.0.0.1");
helper.connect("tcp://127.0.0.1:" + port);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_DISCONNECTED));
monitor.connect("inproc://monitor.socket");
helper.close();
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_DISCONNECTED, event.getEvent());
socket.close();
monitor.close();
context.term();
}
@Test
public void testEventMonitorStopped() {
if (ZMQ.version_full() < ZMQ.make_version(4, 0, 0)) // EVENT_MONITOR_STOPPED added in 4.0.0
return;
Context context = ZMQ.context(1);
Event event;
Socket socket = context.socket(ZMQ.REP);
Socket monitor = context.socket(ZMQ.PAIR);
monitor.setReceiveTimeOut(100);
assertTrue(socket.monitor("inproc://monitor.socket", ZMQ.EVENT_MONITOR_STOPPED));
monitor.connect("inproc://monitor.socket");
socket.monitor(null, 0);
event = Event.recv(monitor);
assertNotNull("No event was received", event);
assertEquals(ZMQ.EVENT_MONITOR_STOPPED, event.getEvent());
socket.close();
monitor.close();
context.term();
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZMsgTest.java 0000664 0000000 0000000 00000013357 12360016021 0021652 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.junit.Test;
import org.zeromq.ZMQ.Socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ZMsgTest {
@Test
public void testMessageEquals() {
ZMsg msg = new ZMsg();
ZFrame hello = new ZFrame("Hello");
ZFrame world = new ZFrame("World");
msg.add(hello);
msg.add(world);
assertEquals(msg, msg.duplicate());
ZMsg reverseMsg = new ZMsg();
msg.add(hello);
msg.addFirst(world);
assertFalse(msg.equals(reverseMsg));
}
@Test
public void testSingleFrameMessage() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zmsg.test");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zmsg.test");
// Test send and receive of a single ZMsg
ZMsg msg = new ZMsg();
ZFrame frame = new ZFrame("Hello");
msg.addFirst(frame);
assertEquals(1, msg.size());
assertEquals(5, msg.contentSize());
msg.send(output);
ZMsg msg2 = ZMsg.recvMsg(input);
assertTrue(msg2 != null);
assertEquals(1, msg2.size());
assertEquals(5, msg2.contentSize());
msg.destroy();
msg2.destroy();
ctx.destroy();
}
@Test
public void testMultiPart() {
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.PAIR);
output.bind("inproc://zmsg.test2");
Socket input = ctx.createSocket(ZMQ.PAIR);
input.connect("inproc://zmsg.test2");
ZMsg msg = new ZMsg();
for (int i = 0; i < 10; i++)
msg.addString("Frame" + i);
ZMsg copy = msg.duplicate();
copy.send(output);
msg.send(output);
copy = ZMsg.recvMsg(input);
assertTrue(copy != null);
assertEquals(10, copy.size());
assertEquals(60, copy.contentSize());
copy.destroy();
msg = ZMsg.recvMsg(input);
assertTrue(msg != null);
assertEquals(10, msg.size());
int count = 0;
for (ZFrame f : msg)
assertTrue(f.streq("Frame" + count++));
assertEquals(60, msg.contentSize());
msg.destroy();
ctx.destroy();
}
@Test
public void testMessageFrameManipulation() {
ZMsg msg = new ZMsg();
for (int i = 0; i < 10; i++)
msg.addString("Frame" + i);
// Remove all frames apart from the first and last one
for (int i = 0; i < 8; i++) {
Iterator iter = msg.iterator();
iter.next(); // Skip first frame
ZFrame f = iter.next();
msg.remove(f);
f.destroy();
}
assertEquals(2, msg.size());
assertEquals(12, msg.contentSize());
assertTrue(msg.getFirst().streq("Frame0"));
assertTrue(msg.getLast().streq("Frame9"));
ZFrame f = new ZFrame("Address");
msg.push(f);
assertEquals(3, msg.size());
assertTrue(msg.getFirst().streq("Address"));
msg.addString("Body");
assertEquals(4, msg.size());
ZFrame f0 = msg.pop();
assertTrue(f0.streq("Address"));
msg.destroy();
msg = new ZMsg();
f = new ZFrame("Address");
msg.wrap(f);
assertEquals(2, msg.size());
msg.addString("Body");
assertEquals(3, msg.size());
f = msg.unwrap();
f.destroy();
assertEquals(1, msg.size());
msg.destroy();
}
@Test
public void testEmptyMessage() {
ZMsg msg = new ZMsg();
assertEquals(0, msg.size());
assertEquals(null, msg.getFirst());
assertEquals(null, msg.getLast());
assertTrue(msg.isEmpty());
assertEquals(null, msg.pop());
assertEquals(null, msg.removeFirst());
assertEquals(false, msg.removeFirstOccurrence(null));
assertEquals(null, msg.removeLast());
msg.destroy();
}
@Test
public void testLoadSave() {
ZMsg msg = new ZMsg();
for (int i = 0; i < 10; i++)
msg.addString("Frame" + i);
try {
// Save msg to a file
File f = new File("zmsg.test");
DataOutputStream dos = new DataOutputStream(new FileOutputStream(f));
assertTrue(ZMsg.save(msg, dos));
dos.close();
// Read msg out of the file
DataInputStream dis = new DataInputStream(new FileInputStream(f));
ZMsg msg2 = ZMsg.load(dis);
dis.close();
f.delete();
assertEquals(10, msg2.size());
assertEquals(60, msg2.contentSize());
} catch (FileNotFoundException e) {
e.printStackTrace();
assertTrue(false);
} catch (IOException e) {
e.printStackTrace();
assertTrue(false);
}
}
@Test
public void testNewStringMessage() {
// A single string => frame
ZMsg msg = ZMsg.newStringMsg("Foo");
assertEquals(1, msg.size());
assertTrue(msg.getFirst().streq("Foo"));
// Multiple strings => frames
ZMsg msg2 = ZMsg.newStringMsg("Foo", "Bar", "Baz");
assertEquals(3, msg2.size());
assertTrue(msg2.getFirst().streq("Foo"));
assertTrue(msg2.getLast().streq("Baz"));
// Empty message (Not very useful)
ZMsg msg3 = ZMsg.newStringMsg();
assertTrue(msg3.isEmpty());
}
}
jzmq-3.1.0/src/test/java/org/zeromq/ZThreadTest.java 0000664 0000000 0000000 00000002472 12360016021 0022327 0 ustar 00root root 0000000 0000000 package org.zeromq;
import org.zeromq.ZMQ.Socket;
import org.junit.Assert;
import org.junit.Test;
public class ZThreadTest {
@Test
public void testDetached() {
ZThread.IDetachedRunnable detached = new ZThread.IDetachedRunnable() {
@Override
public void run(Object[] args) {
ZContext ctx = new ZContext();
assert (ctx != null);
Socket push = ctx.createSocket(ZMQ.PUSH);
assert (push != null);
ctx.destroy();
}
};
ZThread.start(detached);
}
@Test
public void testFork() {
ZContext ctx = new ZContext();
ZThread.IAttachedRunnable attached = new ZThread.IAttachedRunnable() {
@Override
public void run(Object[] args, ZContext ctx, Socket pipe) {
// Create a socket to check it'll be automatically deleted
ctx.createSocket(ZMQ.PUSH);
pipe.recvStr();
pipe.send("pong");
}
};
Socket pipe = ZThread.fork(ctx, attached);
assert (pipe != null);
pipe.send("ping");
String pong = pipe.recvStr();
Assert.assertEquals(pong, "pong");
// Everything should be cleanly closed now
ctx.destroy();
}
}