.
jeromq-0.3.5/COPYING.LESSER 0000664 0000000 0000000 00000022625 12551504772 0015062 0 ustar 00root root 0000000 0000000 GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
org.zeromq
jeromq
0.3.4
org.zeromq
jeromq
0.3.5-SNAPSHOT
sonatype-nexus-snapshots
https://oss.sonatype.org/content/repositories/snapshots
false
true
```
## Using ANT
To generate an ant build file from `pom.xml`, issue the following command:
```bash
mvn ant:ant
```
Also please refer the [Wiki](https://github.com/zeromq/jeromq/wiki).
## Copying
Free use of this software is granted under the terms of the GNU Lesser General
Public License (LGPL). For details see the files `COPYING` and `COPYING.LESSER`
included with the JeroMQ distribution.
jeromq-0.3.5/pom.xml 0000664 0000000 0000000 00000015467 12551504772 0014356 0 ustar 00root root 0000000 0000000
4.0.0
org.zeromq
jeromq
jar
0.3.5
JeroMQ
Pure Java implementation of libzmq
https://github.com/zeromq/jeromq
GNU General Lesser Public License (LGPL) version 3.0
http://www.gnu.org/licenses/lgpl-3.0.html
org.sonatype.oss
oss-parent
7
git@github.com:zeromq/jeromq.git
scm:git:git@github.com:zeromq/jeromq.git
scm:git:git@github.com:zeromq/jeromq.git
v0.3.5
UTF-8
junit
junit
4.11
test
org.apache.maven.plugins
maven-source-plugin
2.4
attach-sources
jar
org.apache.maven.plugins
maven-javadoc-plugin
2.10.1
attach-javadocs
jar
org.apache.maven.plugins
maven-compiler-plugin
3.2
1.6
1.6
maven-jar-plugin
${project.build.outputDirectory}/META-INF/MANIFEST.MF
org.apache.felix
maven-bundle-plugin
2.3.7
true
*
bundle-manifest
process-classes
manifest
org.apache.maven.plugins
maven-checkstyle-plugin
2.11
validate
check
true
true
${project.basedir}/src/checkstyle/checks.xml
true
**/guide/*
org.apache.maven.plugins
maven-release-plugin
2.5.1
v@{project.version}
org.eclipse.m2e
lifecycle-mapping
1.0.0
org.apache.maven.plugins
maven-checkstyle-plugin
[2.11,)
check
doclint-java8-disable
[1.8,)
org.apache.maven.plugins
maven-javadoc-plugin
2.9.1
-Xdoclint:none
attach-javadocs
jar
release-sign-artifacts
performRelease
true
org.apache.maven.plugins
maven-gpg-plugin
1.4
sign-artifacts
verify
sign
jeromq-0.3.5/src/ 0000775 0000000 0000000 00000000000 12551504772 0013613 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/checkstyle/ 0000775 0000000 0000000 00000000000 12551504772 0015751 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/checkstyle/checks.xml 0000664 0000000 0000000 00000012002 12551504772 0017726 0 ustar 00root root 0000000 0000000
jeromq-0.3.5/src/main/ 0000775 0000000 0000000 00000000000 12551504772 0014537 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/main/java/ 0000775 0000000 0000000 00000000000 12551504772 0015460 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/main/java/org/ 0000775 0000000 0000000 00000000000 12551504772 0016247 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/main/java/org/zeromq/ 0000775 0000000 0000000 00000000000 12551504772 0017564 5 ustar 00root root 0000000 0000000 jeromq-0.3.5/src/main/java/org/zeromq/ZActor.java 0000664 0000000 0000000 00000051470 12551504772 0021640 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* This implementation is based on the {@link ZStar} one (TODO via inheritance now but this is not totally stamped and the use of the ZAgent would probably limit the collateral damages if changed)
* so you should be first familiar with the metaphor there.
*
* A side or endpoint designates the same thing: the thread where lives one of the two parts of the Actor system.
*
* - the Plateau side, or background side where all the performances are made by the provided actor.
*
*
* The main purpose (or at least its intent) of this class is to clarify the contracts, roles, responsibilities and action levers related to the Plateau.
*
* The provided Actor will not be alone to do the processing of each loop.
*
* The ZActor takes care of the establishment of the background processing, calling the provided Actor
* at appropriate times via its Double. It can also manage the {@link #sign() exited} state on the control side,
* if using the provided {@link #send(ZMsg)} or {@link #recv()} methods.
*
* An {@link Actor actor} is basically a contract interface that anyone who uses this ZActor SHALL comply to.
* PS: Je sais qu'il y a une différence entre acteur et comédien :)
* PPS: I know nothing about theater!
*
* Example of code for a minimalistic actor with no socket handling other than the control pipe:
*
*
*
* {@code
Actor acting = new ZActor.SimpleActor()
{
public List createSockets(ZContext ctx, Object[] args)
{
assert ("TEST".equals(args[0]));
return Arrays.asList(ctx.createSocket(ZMQ.PUB));
}
public boolean backstage(Socket pipe, ZPoller poller, int events)
{
String cmd = pipe.recvStr();
if ("HELLO".equals(cmd)) {
pipe.send("WORLD");
// end of the actor
return false;
}
return true;
}
};
ZActor actor = new ZActor(acting, "LOCK", Arrays.asList("TEST").toArray());
Socket pipe = actor.pipe();
boolean rc = pipe.send("HELLO");
assert (rc);
ZMsg msg = actor.recv();
String world = msg.popString();
assert ("WORLD".equals(world));
msg = actor.recv();
assert (msg == null);
rc = actor.sign();
assert (!rc);
rc = actor.send("whatever");
assert (!rc);
// don't try to use the pipe
}
*/
// remote controlled background message processing API for 0MQ.
public class ZActor extends ZStar
// once on stage, any actor IS a star
{
/**
* Defines the contract for the acting instance.
*
*/
// contract interface for acting on the distant stage
// TODO what can be done to reduce the amount of methods ? Split interface?
public interface Actor
{
/**
* This is the grand premiere!
* Called before the creation of the first double and the sockets
* 2nd in the order call of the global acting.
*
* @param pipe the backstage control pipe
* @return the name of the upcoming performance
*/
String premiere(Socket pipe);
/**
* Creates and initializes sockets for the double.
* This is done at each creation of a new double.
* 3rd in the order call of the global acting.
* 1st in the order call of the new double.
*
* @param ctx the context used to create sockets
* @param args the arguments passed as parameters of the ZActor
* @return a list of created sockets that will be managed by the double. Not null.
*/
List createSockets(ZContext ctx, Object[] args);
/**
* Called when the double is started, before the first loop.
* 4th in the order call of the global acting.
* 2nd in the order call of the new double.
*
* @param pipe the backstage control pipe
* @param sockets the managed sockets that were created in the previous step
* @param poller the poller where to eventually register the sockets for events
*/
void start(Socket pipe, List sockets, ZPoller poller);
/**
* Called every time just before a loop starts.
* 5th in the order call of the global acting.
* 3nd in the order call of the new double.
* 1st in the order call of the new loop.
*
* @param pipe the backstage control pipe
* @param poller the poller of the double
* @return the timeout of the coming loop. -1 to block, 0 to not wait, > 0 to wait till max the returned duration in milliseconds
*/
long looping(Socket pipe, ZPoller poller);
/**
* Called when the actor received a control message from its pipe during a loop.
* 2nd in the order call of the new loop.
*
* @param pipe the backstage control pipe receiving the message
* @param poller the poller of the double.
* @param events the events source of the call
* @return true in case of success, false to stop the double .
*/
boolean backstage(Socket pipe, ZPoller poller, int events);
/**
* The actor received a message from the created sockets during a loop.
* 2nd ex-aequo in the order call of the new loop.
*
* @param socket the socket receiving the message
* @param pipe the backstage control pipe
* @param poller the poller of the double.
* @param events the events source of the call
* @return true in case of success, false to stop the double .
*/
boolean stage(Socket socket, Socket pipe, ZPoller poller, int events);
/**
* Called at the end of each loop.
* 3rd in the order call of the new loop.
*
* @param pipe the backstage control pipe
* @param poller the poller of the double.
* @return true to continue with the current double, false to stop it .
*/
boolean looped(Socket pipe, ZPoller poller);
/**
* Called when a created socket has been closed.
* The process of destroying the double has already started.
*
* @param socket the closed socked.
*/
void closed(Socket socket);
/**
* Called when the current double has been destroyed.
* Last in the order call of the double.
*
* @param pipe the backstage control pipe
* @param poller the poller of the double.
* @return true to restart a new double , false to stop the acting process
*/
boolean destroyed(Socket pipe, ZPoller poller);
/**
* Called when the stage is finished.
* This is the last call to the actor.
* Last in the order call of the global acting.
*
* @param pipe the backstage control pipe
* @return true to spread the word of the actor's leaving
*/
boolean finished(Socket pipe);
}
/**
* Simple adapter for an actor, with no sockets, blocking calls and immediate termination.
*/
// simple contract implementation for acting on the stage
public static class SimpleActor implements Actor
{
@Override
public String premiere(final Socket pipe)
{
// do nothing
return "?";
}
@Override
public List createSockets(final ZContext ctx,
final Object[] args)
{
return Collections.emptyList();
}
@Override
public void start(final Socket pipe, final List sockets,
final ZPoller poller)
{
// do nothing
}
@Override
public long looping(Socket pipe, ZPoller poller)
{
// blocking loop
return -1;
}
@Override
public boolean backstage(final Socket pipe, final ZPoller poller,
final int events)
{
// stop looping
return false;
}
@Override
public boolean stage(final Socket socket, final Socket pipe,
final ZPoller poller, int events)
{
// stop looping
return false;
}
@Override
public boolean looped(final Socket pipe, final ZPoller poller)
{
// continue with the same double
return true;
}
@Override
public void closed(final Socket socket)
{
// do nothing
}
@Override
public boolean destroyed(final Socket pipe, ZPoller poller)
{
// no restart
return false;
}
@Override
public boolean finished(final Socket pipe)
{
// mot de la fin if not null
return true;
}
}
/**
* Another actor will be called just before the main one,
* without participating to the decisions.
*/
// contract implementation for a duo actor on the stage
public static class Duo implements Actor
{
// the actor that will play an active role on the stage
private final Actor main;
// the actor that will play a passive role on the stage
private final Actor shadow;
public Duo(final Actor main, final Actor shadow)
{
super();
assert (main != null);
assert (shadow != null);
this.main = main;
this.shadow = shadow;
}
@Override
public String premiere(final Socket pipe)
{
shadow.premiere(pipe);
return main.premiere(pipe);
}
@Override
public List createSockets(final ZContext ctx,
final Object[] args)
{
shadow.createSockets(ctx, args);
return main.createSockets(ctx, args);
}
@Override
public void start(final Socket pipe, final List sockets,
final ZPoller poller)
{
shadow.start(pipe, sockets, poller);
main.start(pipe, sockets, poller);
}
@Override
public long looping(Socket pipe, ZPoller poller)
{
shadow.looping(pipe, poller);
return main.looping(pipe, poller);
}
@Override
public boolean backstage(final Socket pipe, final ZPoller poller,
final int events)
{
shadow.backstage(pipe, poller, events);
return main.backstage(pipe, poller, events);
}
@Override
public boolean stage(final Socket socket, final Socket pipe,
final ZPoller poller, final int events)
{
shadow.stage(socket, pipe, poller, events);
return main.stage(socket, pipe, poller, events);
}
@Override
public boolean looped(final Socket pipe, final ZPoller poller)
{
shadow.looped(pipe, poller);
return main.looped(pipe, poller);
}
@Override
public void closed(final Socket socket)
{
shadow.closed(socket);
main.closed(socket);
}
@Override
public boolean destroyed(final Socket pipe, final ZPoller poller)
{
shadow.destroyed(pipe, poller);
return main.destroyed(pipe, poller);
}
@Override
public boolean finished(final Socket pipe)
{
shadow.finished(pipe);
return main.finished(pipe);
}
}
/**
* Creates a new ZActor.
*
* @param actor
* the actor handling messages from either stage and backstage
* @param args
* the optional arguments that will be passed to the distant actor
*/
public ZActor(Actor actor, final String motdelafin, Object... args)
{
this(null, null, actor, motdelafin, args);
}
/**
* Creates a new ZActor.
*
* @param selector
* the creator of the selector used on the Plateau.
* @param actor
* the actor handling messages from either stage and backstage
* @param args
* the optional arguments that will be passed to the distant actor
*/
public ZActor(final SelectorCreator selector, final Actor actor, final String motdelafin, final Object... args)
{
this(null, selector, actor, motdelafin, args);
}
/**
* Creates a new ZActor.
*
* @param context
* the main context used. If null, a new context will be created
* and closed at the stop of the operation.
* If not null, it is the responsibility of the caller to close it.
*
* @param selector
* the creator of the selector used on the Plateau.
* @param actor
* the actor handling messages from either stage and backstage
* @param args
* the optional arguments that will be passed to the distant actor
*/
public ZActor(final ZContext context, final SelectorCreator selector,
final Actor actor, final String motdelafin, final Object[] args)
{
super(context, selector, new ActorFortune(actor), motdelafin, args);
}
// actor creator
private static final class ActorFortune implements Fortune
{
private final Actor actor;
public ActorFortune(Actor actor)
{
assert (actor != null);
this.actor = actor;
}
@Override
public String premiere(Socket mic, Object[] args)
{
return actor.premiere(mic);
}
@Override
public Star create(ZContext ctx, Socket pipe, Selector sel,
int count, Star previous, Object[] args)
{
Star star = new ZActor.Double(ctx, pipe, sel, actor, args);
return star;
}
@Override
public boolean interview(Socket mic)
{
return actor.finished(mic);
}
@Override
public void party(ZContext ctx)
{
}
}
// double for the loops, easing life for the actor
private static final class Double implements EventsHandler, Star
{
// poller used for the loop
private final ZPoller poller;
// control pipe for Backstage side
private final Socket pipe;
// managed sockets
private final List sockets;
// actor responsible for processing messages
private final Actor actor;
// creates a new double
public Double(final ZContext ctx, final Socket pipe,
final Selector selector, final Actor actor,
final Object[] args)
{
this.pipe = pipe;
this.actor = actor;
final List created = actor.createSockets(ctx, args);
assert (created != null);
sockets = new ArrayList(created);
poller = new ZPoller(selector);
poller.setGlobalHandler(this);
}
// before starting the loops
@Override
public void prepare()
{
poller.register(pipe, ZPoller.POLLIN);
actor.start(pipe, Collections.unmodifiableList(sockets), poller);
}
// gives the number of events to process
@Override
public int breathe()
{
long timeout = actor.looping(pipe, poller);
return poller.poll(timeout);
// events have been dispatched,
}
// acting takes place, return true to continue till the end
@Override
public boolean act(int events)
{
// act is actually already finished for handlers
return events >= 0; // Context is not shut down
}
// a loop just finished, return true to continue acting
@Override
public boolean entract()
{
return actor.looped(pipe, poller);
}
// destroys the double
@Override
public boolean renews()
{
// close every managed sockets
Iterator iter = sockets.iterator();
while (iter.hasNext()) {
final Socket socket = iter.next();
iter.remove();
if (socket != null) {
poller.unregister(socket);
socket.close();
// call back the actor to inform that a socket has been closed.
actor.closed(socket);
}
}
// let the actor decide if the stage restarts a new double
return actor.destroyed(pipe, poller);
}
@Override
public boolean events(SelectableChannel channel, int events)
{
// TODO dispatch events from channels
return true;
}
// an event has occurred on a registered socket
@Override
public boolean events(final Socket socket, final int events)
{
if (socket != pipe) {
// Process a stage message, time to play
return actor.stage(socket, pipe, poller, events);
}
else {
// Process a control message, time to update your playing
return actor.backstage(pipe, poller, events);
}
}
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZAgent.java 0000664 0000000 0000000 00000017150 12551504772 0021623 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* An agent is a mechanism allowing to send messages from one thread to another, and to receive messages from this other thread.
*
* Its built-in implementation provides an easy communication-lock
* system that will close the access once the remote thread is finished.
*
* Are proposed for you a restrained set of simple but powerful messaging commands for a quick learning curve
* and an access to the underlying Socket for advanced usage.
*/
// agent for a remote controlled background message processing API for 0MQ.
// contract to be agent of a star
public interface ZAgent
{
/**
* Receives a control message sent from the Plateau in the Corbeille.
* The call is blocking.
*
* @return the received message or null if the context was shut down.
*/
ZMsg recv();
/**
* Receives a control message sent from the Plateau in the Corbeille.
* The call is blocking depending on the parameter.
*
* @param wait true to make a blocking call, false to not wait, and possibly return null
* @return the received message or null if the context was shut down or if no message if not blocking.
*/
ZMsg recv(boolean wait);
/**
* Sends a control message from the Corbeille to the Plateau.
*
* @param message the message to send
* @return true if the message was sent, otherwise false (if the distant Star is dead for example)
*/
boolean send(ZMsg message);
/**
* Sends a control message from Corbeille side to the Plateau side.
*
* @param msg the message to send
* @param destroy true to destroy the message after sending it.
* @return true if the message was sent, otherwise false (if the distant Star is dead for example)
*/
boolean send(ZMsg msg, boolean destroy);
/**
* Sends a control message from the Corbeille to the Plateau side.
*
* @param word the message to send
* @return true if the message was sent, otherwise false (if the distant Star is dead for example)
*/
boolean send(String word);
/**
* Sends a control message from the Corbeille to the Plateau side.
*
* @param word the message to send
* @param more true to send more strings in a single message
* @return true if the message was sent, otherwise false (if the distant Star is dead for example)
*/
boolean send(String word, boolean more);
/**
* Gives a sign if the distant Star is here.
*
* @return true if here, otherwise false
*/
boolean sign();
/**
* Forcely destroys the Star.
* @deprecated not sure it is useful or recommended
*/
@Deprecated
void nova();
/**
* Returns the socket used for communication.
* For advanced usage.
*
* @return the socket used to communicate with the distant Star.
*/
Socket pipe();
public static class Creator
{
public static ZAgent create(Socket pipe, String lock)
{
return new SimpleAgent(pipe, lock);
}
}
/**
* Creates a very simple agent with an easy lock mechanism.
*/
public static final class SimpleAgent implements ZAgent
{
// the pipe used for communicating with the star
private final Socket pipe;
// the key used to lock the agent.
private final byte[] lock;
// the locked state.
private boolean locked;
/**
* Creates a new simple agent.
*
* @param pipe the pipe used to send control messages to the distant IStar.
* @param lock the lock to use. If null, the locking mechanism is omitted.
*/
public SimpleAgent(Socket pipe, String lock)
{
this.pipe = pipe;
this.lock = lock == null ? null : lock.getBytes(ZMQ.CHARSET);
}
@Override
public boolean sign()
{
return !locked;
}
@Override
public ZMsg recv()
{
return recv(true);
}
@Override
public ZMsg recv(boolean wait)
{
if (locked) {
return null;
}
ZMsg msg = ZMsg.recvMsg(pipe, wait ? 0 : ZMQ.DONTWAIT);
if (msg == null) {
return null;
}
final ZFrame frame = msg.peek();
byte[] key = frame.getData();
if (lock != null && Arrays.equals(lock, key)) {
locked = true;
// this is the last message anyway, and not a one for a public display
msg = null;
pipe.close();
}
return msg;
}
@Override
public boolean send(ZMsg message)
{
if (locked) {
return false;
}
return message.send(pipe);
}
@Override
public boolean send(String word)
{
if (locked) {
return false;
}
return pipe.send(word);
}
@Override
public boolean send(String word, boolean more)
{
if (locked) {
return false;
}
return pipe.send(word, more ? ZMQ.SNDMORE : 0);
}
@Override
public boolean send(ZMsg msg, boolean destroy)
{
if (locked) {
return false;
}
return msg.send(pipe, destroy);
}
@Override
public Socket pipe()
{
return pipe;
}
@Override
public void nova()
{
pipe.close();
}
}
/**
* Creates a selector and destroys it.
*/
// Contract for selector creation.
// will be called in backstage side.
public static interface SelectorCreator
{
/**
* Creates and opens a selector.
*
* @return the opened selector.
*/
Selector create() throws IOException;
/**
* Destroys the previously opened selector.
* @param selector the selector to close
*/
void destroy(Selector selector) throws IOException;
}
// very simple selector creator
public static class VerySimpleSelectorCreator implements SelectorCreator
{
@Override
public Selector create() throws IOException
{
return Selector.open();
}
@Override
public void destroy(Selector selector) throws IOException
{
if (selector != null) {
selector.close();
}
}
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZBeacon.java 0000664 0000000 0000000 00000017250 12551504772 0021755 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 sockets;
/**
* Number of io threads allocated to this context, default 1
*/
private int ioThreads;
/**
* Linger timeout, default 0
*/
private int linger;
/**
* HWM timeout, default 1
*/
private int hwm;
/**
* Indicates if context object is owned by main thread
* (useful for multi-threaded applications)
*/
private boolean main;
/**
* Class Constructor
*/
public ZContext()
{
this(1);
}
public ZContext(int ioThreads)
{
sockets = new CopyOnWriteArrayList();
this.ioThreads = ioThreads;
linger = 0;
main = true;
}
/**
* Destructor. Call this to gracefully terminate context and close any managed 0MQ sockets
*/
public void destroy()
{
for (Socket socket : sockets) {
try {
socket.setLinger(linger);
}
catch (ZError.CtxTerminatedException e) {
}
socket.close();
}
sockets.clear();
// Only terminate context if we are on the main thread
if (isMain() && context != null) {
context.term();
}
context = null;
}
/**
* Creates a new managed socket within this ZContext instance.
* Use this to get automatic management of the socket at shutdown
* @param type
* socket type (see ZMQ static class members)
* @return
* Newly created Socket object
*/
public Socket createSocket(int type)
{
// Create and register socket
Socket socket = getContext().socket(type);
sockets.add(socket);
return socket;
}
/**
* Destroys managed socket within this context
* and remove from sockets list
* @param s
* org.zeromq.Socket object to destroy
*/
public void destroySocket(Socket s)
{
if (s == null) {
return;
}
if (sockets.contains(s)) {
try {
s.setLinger(linger);
}
catch (ZError.CtxTerminatedException e) {
}
s.close();
sockets.remove(s);
}
}
/**
* Creates new shadow context.
* Shares same underlying org.zeromq.Context instance but has own list
* of managed sockets, io thread count etc.
* @param ctx Original ZContext to create shadow of
* @return New ZContext
*/
public static ZContext shadow(ZContext ctx)
{
ZContext shadow = new ZContext();
shadow.setContext(ctx.getContext());
shadow.setMain(false);
return shadow;
}
/**
* @return the ioThreads
*/
public int getIoThreads()
{
return ioThreads;
}
/**
* @param ioThreads the ioThreads to set
*/
public void setIoThreads(int ioThreads)
{
this.ioThreads = ioThreads;
}
/**
* @return the linger
*/
public int getLinger()
{
return linger;
}
/**
* @param linger the linger to set
*/
public void setLinger(int linger)
{
this.linger = linger;
}
/**
* @return the HWM
*/
public int getHWM()
{
return hwm;
}
/**
* @param hwm the HWM to set
*/
public void setHWM(int hwm)
{
this.hwm = hwm;
}
/**
* @return the main
*/
public boolean isMain()
{
return main;
}
/**
* @param main the main to set
*/
public void setMain(boolean main)
{
this.main = main;
}
/**
* @return the context
*/
public Context getContext()
{
Context result = context;
if (result == null) {
synchronized (this) {
result = context;
if (result == null) {
result = ZMQ.context(ioThreads);
context = result;
}
}
}
return result;
}
/**
* @param ctx sets the underlying org.zeromq.Context associated with this ZContext wrapper object
*/
public void setContext(Context ctx)
{
this.context = ctx;
}
/**
* @return the sockets
*/
public List getSockets()
{
return sockets;
}
@Override
public void close()
{
destroy();
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZFrame.java 0000664 0000000 0000000 00000026244 12551504772 0021623 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pollers; // List of poll items
private final List timers; // List of timers
private int pollSize; // Size of poll set
private Poller pollset; // zmq_poll set
private SPoller[] pollact; // Pollers for this poll set
private boolean dirty; // True if pollset needs rebuilding
private boolean verbose; // True if verbose tracing wanted
private final List zombies; // List of timers to kill
private final List newTimers; // List of timers to add
public ZLoop()
{
pollers = new ArrayList();
timers = new ArrayList();
zombies = new ArrayList();
newTimers = new ArrayList();
}
public void destroy()
{
// do nothing
}
// We hold an array of pollers that matches the pollset, so we can
// register/cancel pollers orthogonally to executing the pollset
// activity on pollers. Returns 0 on success, -1 on failure.
private void rebuild()
{
pollact = null;
pollSize = pollers.size();
pollset = new Poller(pollSize);
pollact = new SPoller[pollSize];
int itemNbr = 0;
for (SPoller poller : pollers) {
pollset.register(poller.item);
pollact[itemNbr] = poller;
itemNbr++;
}
dirty = false;
}
private long ticklessTimer()
{
// Calculate tickless timer, up to 1 hour
long tickless = System.currentTimeMillis() + 1000 * 3600;
for (STimer timer : timers) {
if (timer.when == -1) {
timer.when = timer.delay + System.currentTimeMillis();
}
if (tickless > timer.when) {
tickless = timer.when;
}
}
long timeout = tickless - System.currentTimeMillis();
if (timeout < 0) {
timeout = 0;
}
if (verbose) {
System.out.printf("I: zloop: polling for %d msec\n", timeout);
}
return timeout;
}
// --------------------------------------------------------------------------
// Register pollitem with the reactor. When the pollitem is ready, will call
// the handler, passing the arg. Returns 0 if OK, -1 if there was an error.
// If you register the pollitem more than once, each instance will invoke its
// corresponding handler.
public int addPoller(PollItem pollItem, IZLoopHandler handler, Object arg)
{
if (pollItem.getRawSocket() == null && pollItem.getSocket() == null) {
return -1;
}
SPoller poller = new SPoller(pollItem, handler, arg);
pollers.add(poller);
dirty = true;
if (verbose) {
System.out.printf("I: zloop: register %s poller (%s, %s)\n",
pollItem.getSocket() != null ? pollItem.getSocket().getType() : "RAW",
pollItem.getSocket(), pollItem.getRawSocket());
}
return 0;
}
// --------------------------------------------------------------------------
// Cancel a pollitem from the reactor, specified by socket or FD. If both
// are specified, uses only socket. If multiple poll items exist for same
// socket/FD, cancels ALL of them.
public void removePoller(PollItem pollItem)
{
Iterator it = pollers.iterator();
while (it.hasNext()) {
SPoller p = it.next();
if (pollItem.equals(p.item)) {
it.remove();
dirty = true;
}
}
if (verbose) {
System.out.printf("I: zloop: cancel %s poller (%s, %s)",
pollItem.getSocket() != null ? pollItem.getSocket().getType() : "RAW",
pollItem.getSocket(), pollItem.getRawSocket());
}
}
// --------------------------------------------------------------------------
// Register a timer that expires after some delay and repeats some number of
// times. At each expiry, will call the handler, passing the arg. To
// run a timer forever, use 0 times. Returns 0 if OK, -1 if there was an
// error.
public int addTimer(int delay, int times, IZLoopHandler handler, Object arg)
{
STimer timer = new STimer(delay, times, handler, arg);
// We cannot touch self->timers because we may be executing that
// from inside the poll loop. So, we hold the new timer on the newTimers
// list, and process that list when we're done executing timers.
newTimers.add(timer);
if (verbose) {
System.out.printf("I: zloop: register timer delay=%d times=%d\n", delay, times);
}
return 0;
}
// --------------------------------------------------------------------------
// Cancel all timers for a specific argument (as provided in zloop_timer)
// Returns 0 on success.
public int removeTimer(Object arg)
{
assert (arg != null);
// We cannot touch self->timers because we may be executing that
// from inside the poll loop. So, we hold the arg on the zombie
// list, and process that list when we're done executing timers.
zombies.add(arg);
if (verbose) {
System.out.printf("I: zloop: cancel timer\n");
}
return 0;
}
// --------------------------------------------------------------------------
// Set verbose tracing of reactor on/off
public void verbose(boolean verbose)
{
this.verbose = verbose;
}
// --------------------------------------------------------------------------
// Start the reactor. Takes control of the thread and returns when the 0MQ
// context is terminated or the process is interrupted, or any event handler
// returns -1. Event handlers may register new sockets and timers, and
// cancel sockets. Returns 0 if interrupted, -1 if cancelled by a
// handler, positive on internal error
public int start()
{
int rc = 0;
timers.addAll(newTimers);
newTimers.clear();
// Recalculate all timers now
for (STimer timer : timers) {
timer.when = timer.delay + System.currentTimeMillis();
}
// Main reactor loop
while (!Thread.currentThread().isInterrupted()) {
if (dirty) {
// If s_rebuild_pollset() fails, break out of the loop and
// return its error
rebuild();
}
long wait = ticklessTimer();
rc = pollset.poll(wait);
if (rc == -1) {
if (verbose) {
System.out.printf("I: zloop: interrupted (%d)\n", rc);
}
rc = 0;
break; // Context has been shut down
}
// Handle any timers that have now expired
Iterator 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)\n",
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;
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZMQ.java 0000664 0000000 0000000 00000200220 12551504772 0021072 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* 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 "http://api.zeromq.org/3-0:zmq-poll"
*
* @return how many objects where signaled by poll ()
*/
public int poll(long tout)
{
zmq.PollItem[] pollItems = new zmq.PollItem[next];
for (int i = 0; i < next; i++) {
pollItems[i] = items[i].base();
}
return zmq.ZMQ.poll(pollItems, next, tout);
}
/**
* Check whether the specified element in the poll set was signaled for input.
*
* @param index
*
* @return true if the element was signaled.
*/
public boolean pollin(int index)
{
if (index < 0 || index >= this.next) {
return false;
}
return items[index].isReadable();
}
/**
* Check whether the specified element in the poll set was signaled for output.
*
* @param index
*
* @return true if the element was signaled.
*/
public boolean pollout(int index)
{
if (index < 0 || index >= this.next) {
return false;
}
return items[index].isWritable();
}
/**
* Check whether the specified element in the poll set was signaled for error.
*
* @param index
*
* @return true if the element was signaled.
*/
public boolean pollerr(int index)
{
if (index < 0 || index >= this.next) {
return false;
}
return items[index].isError();
}
}
public static class PollItem
{
private final zmq.PollItem base;
private final Socket socket;
public PollItem(Socket socket, int ops)
{
this.socket = socket;
base = new zmq.PollItem(socket.base, ops);
}
public PollItem(SelectableChannel channel, int ops)
{
base = new zmq.PollItem(channel, ops);
socket = null;
}
protected final zmq.PollItem base()
{
return base;
}
public final SelectableChannel getRawSocket()
{
return base.getRawSocket();
}
public final Socket getSocket()
{
return socket;
}
public final boolean isReadable()
{
return base.isReadable();
}
public final boolean isWritable()
{
return base.isWritable();
}
public final boolean isError()
{
return base.isError();
}
public final int readyOps()
{
return base.readyOps();
}
@Override
public int hashCode()
{
return base.hashCode();
}
@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 (getRawSocket() != null && getRawSocket() == target.getRawSocket()) {
return true;
}
return false;
}
}
public enum Error
{
ENOTSUP(ZError.ENOTSUP),
EPROTONOSUPPORT(ZError.EPROTONOSUPPORT),
ENOBUFS(ZError.ENOBUFS),
ENETDOWN(ZError.ENETDOWN),
EADDRINUSE(ZError.EADDRINUSE),
EADDRNOTAVAIL(ZError.EADDRNOTAVAIL),
ECONNREFUSED(ZError.ECONNREFUSED),
EINPROGRESS(ZError.EINPROGRESS),
EMTHREAD(ZError.EMTHREAD),
EFSM(ZError.EFSM),
ENOCOMPATPROTO(ZError.ENOCOMPATPROTO),
ETERM(ZError.ETERM),
ENOTSOCK(ZError.ENOTSOCK),
EAGAIN(ZError.EAGAIN);
private final int code;
Error(int code)
{
this.code = code;
}
public int 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);
}
}
@Deprecated
public static boolean device(int type, Socket frontend, Socket backend)
{
return zmq.ZMQ.proxy(frontend.base, backend.base, null);
}
/**
* 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.
*/
public static boolean proxy(Socket frontend, Socket backend, Socket capture)
{
return zmq.ZMQ.proxy(frontend.base, backend.base, capture != null ? capture.base : null);
}
public static int poll(PollItem[] items, long timeout)
{
return poll(items, items.length, timeout);
}
public static int poll(PollItem[] items, int count, long timeout)
{
zmq.PollItem[] pollItems = new zmq.PollItem[count];
for (int i = 0; i < count; i++) {
pollItems[i] = items[i].base;
}
return zmq.ZMQ.poll(pollItems, count, timeout);
}
/**
* @return Major version number of the ZMQ library.
*/
public static int getMajorVersion()
{
return zmq.ZMQ.ZMQ_VERSION_MAJOR;
}
/**
* @return Major version number of the ZMQ library.
*/
public static int getMinorVersion()
{
return zmq.ZMQ.ZMQ_VERSION_MINOR;
}
/**
* @return Major version number of the ZMQ library.
*/
public static int getPatchVersion()
{
return zmq.ZMQ.ZMQ_VERSION_PATCH;
}
/**
* @return Full version number of the ZMQ library used for comparing versions.
*/
public static int getFullVersion()
{
return zmq.ZMQ.makeVersion(zmq.ZMQ.ZMQ_VERSION_MAJOR,
zmq.ZMQ.ZMQ_VERSION_MINOR,
zmq.ZMQ.ZMQ_VERSION_PATCH);
}
/**
* @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 zmq.ZMQ.makeVersion(major, minor, patch);
}
/**
* @return String version number in the form major.minor.patch.
*/
public static String getVersionString()
{
return "" + zmq.ZMQ.ZMQ_VERSION_MAJOR + "." +
zmq.ZMQ.ZMQ_VERSION_MINOR + "." +
zmq.ZMQ.ZMQ_VERSION_PATCH;
}
/**
* Inner class: Event.
* Monitor socket event class
*/
public static class Event
{
private final int event;
private final Object value;
private final String 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;
}
public String getAddress()
{
return address;
}
/**
* Receive an event from a monitor socket.
* @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)
{
zmq.ZMQ.Event e = zmq.ZMQ.Event.read(socket.base, flags);
return e != null ? new Event(e.event, e.arg, e.addr) : null;
}
/**
* Receive an event from a monitor socket.
* Does a blocking recv.
* @param socket the socket
* @return the received event.
* @throws ZMQException
*/
public static Event recv(Socket socket)
{
return Event.recv(socket, 0);
}
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZMQException.java 0000664 0000000 0000000 00000003306 12551504772 0022757 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* // 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();
frames = null;
}
/**
* @return total number of bytes contained in all ZFrames in this ZMsg
*/
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.
* @return true if send is success, false otherwise
*/
public boolean send(Socket socket)
{
return send(socket, true);
}
/**
* 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.
* @return true if send is success, false otherwise
*/
public boolean send(Socket socket, boolean destroy)
{
if (socket == null) {
throw new IllegalArgumentException("socket is null");
}
if (frames == null) {
throw new IllegalArgumentException("destroyed message");
}
if (frames.size() == 0) {
return true;
}
boolean ret = true;
Iterator i = frames.iterator();
while (i.hasNext()) {
ZFrame f = i.next();
ret = f.sendAndKeep(socket, (i.hasNext()) ? ZFrame.MORE : 0);
}
if (destroy) {
destroy();
}
return ret;
}
/**
* 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
* ZMsg object, null if interrupted
*/
public static ZMsg recvMsg(Socket socket)
{
return recvMsg(socket, 0);
}
/**
* Receives message from socket, returns ZMsg object or null if the
* recv was interrupted. Setting the flag to ZMQ.DONTWAIT does a non-blocking recv.
* @param socket
* @param flag see ZMQ constants
* @return
* ZMsg object, null if interrupted
*/
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();
msg = null;
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.size(),
frame.toString());
}
out.append(sw.getBuffer());
sw.close();
}
catch (IOException e) {
throw new RuntimeException("Message dump exception "
+ super.toString(), e);
}
}
public void dump()
{
dump(System.out);
}
// ********* 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();
}
/**
* Returns pretty string representation of multipart message:
* [ frame0, frame1, ..., frameN ]
*
* @return toString version of ZMsg object
*/
@Override
public String toString()
{
StringBuilder out = new StringBuilder("[ ");
Iterator frameIterator = frames.iterator();
while (frameIterator.hasNext()) {
out.append(frameIterator.next());
if (frameIterator.hasNext()) {
out.append(", "); // skip last iteration
}
}
out.append(" ]");
return out.toString();
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZPoller.java 0000664 0000000 0000000 00000056251 12551504772 0022027 0 ustar 00root root 0000000 0000000 package org.zeromq;
import java.io.Closeable;
import java.io.IOException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.Selector;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.zeromq.ZMQ.Poller;
import org.zeromq.ZMQ.Socket;
/**
* Rewritten poller for 0MQ.
*
* Polls selectable channels and sockets for specified events.
*
* This poller can be used in two ways:
*
*
* - the traditional one, where you make something like
*
* {@code
ZPoller poller = ...
poller.register(socket, ZPoller.POLLIN);
poller.register(channel, ZPoller.OUT);
int events = poller.poll(-1L);
if (poller.isReadable(socket)) {
...
}
if (poller.writable(channel)) {
...
}
}
* - the event-driven way
*
* {@code
*
ZPoller poller = ...
poller.setGlobalHandler(...)
ZPoller.EventsHandler handler = ...
// The events method of the handler will be called
poller.register(channel, handler, ZPoller.IN);
// The events method of the global handler will be called
poller.register(socket, ZPoller.POLLOUT);
poller.poll(-1L);
// handlers have been called
}
* The motivations of this rewriting are:
* true to continue the polling , false to stop it
*/
boolean events(Socket socket, int events);
/**
* Called when the poller intercepts events.
*
* @param channel the channel with events
* @param events the interesting events as an ORed combination of IN, OUT, ERR
* @return true to continue the polling , false to stop it
*/
boolean events(SelectableChannel channel, int events);
}
// contract for items. Useful for providing own implementation.
public static interface ItemHolder
{
// the inner ZMQ poll item
zmq.PollItem item();
// the related ZeroMQ socket
Socket socket();
// the associated events handler
EventsHandler handler();
}
// contract for items creation. Useful for delegating.
public static interface ItemCreator
{
/**
* Creates a new holder for a poll item.
*
* @param socket the socket to poll
* @param handler the optional handler for polled events
* @param events the interested events
* @return a new poll item holder
*/
ItemHolder create(Socket socket, EventsHandler handler, int events);
/**
* Creates a new holder for a poll item.
*
* @param channel the channel to poll
* @param handler the optional handler for polled events.
* @param events the interested events
* @return a new poll item holder
*/
ItemHolder create(SelectableChannel channel, EventsHandler handler, int events);
}
// re-re-implementation of poll item
public static class ZPollItem extends ZMQ.PollItem implements ItemHolder
{
private final EventsHandler handler;
public ZPollItem(final Socket socket, final EventsHandler handler, int ops)
{
super(socket, ops);
this.handler = handler;
}
public ZPollItem(final SelectableChannel channel, final EventsHandler handler, final int ops)
{
super(channel, ops);
this.handler = handler;
}
@Override
public zmq.PollItem item()
{
return base();
}
@Override
public Socket socket()
{
return getSocket();
}
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + ((item() == null) ? 0 : item().hashCode());
result = prime * result + ((getRawSocket() == null) ? 0 : getRawSocket().hashCode());
result = prime * result + ((socket() == null) ? 0 : socket().hashCode());
result = prime * result + ((handler() == null) ? 0 : handler().hashCode());
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof ItemHolder)) {
return false;
}
ItemHolder other = (ItemHolder) obj;
if (item() == null) {
if (other.item() != null) {
return false;
}
}
else if (!item().equals(other.item())) {
return false;
}
if (item().getRawSocket() == null) {
if (other.item().getRawSocket() != null) {
return false;
}
}
else if (!item().getRawSocket().equals(other.item().getRawSocket())) {
return false;
}
if (socket() == null) {
if (other.socket() != null) {
return false;
}
}
else if (!socket().equals(other.socket())) {
return false;
}
if (handler() == null) {
if (other.handler() != null) {
return false;
}
}
else if (!handler().equals(other.handler())) {
return false;
}
return true;
}
@Override
public EventsHandler handler()
{
return handler;
}
}
/******************************************************************************/
/* 0MQ socket events */
/******************************************************************************/
/**
* These values can be ORed to specify what we want to poll for.
*/
public static final int POLLIN = Poller.POLLIN;
public static final int POLLOUT = Poller.POLLOUT;
public static final int POLLERR = Poller.POLLERR;
// same values with shorter writing
public static final int IN = POLLIN;
public static final int OUT = POLLOUT;
public static final int ERR = POLLERR;
/**
* Creates a new poller based on the current one.
* This will be a shadow poller, sharing the same selector and items creator.
* The global events handler will not be shared.
*
* @param poller the main poller.
*/
public ZPoller(final ZPoller poller)
{
this(poller.creator, poller.selector);
}
/**
* Creates a new poller with a given selector for operational polling.
*
* @param selector the selector to use for polling.
*/
public ZPoller(final Selector selector)
{
this(new SimpleCreator(), selector);
}
/**
* Creates a new poller based on the current one.
* This will be a shadow poller, sharing the same selector.
* The global events handler will not be shared.
*
* @param creator the items creator
* @param poller the main poller.
*/
public ZPoller(final ItemCreator creator, final ZPoller poller)
{
this(creator, poller.selector);
}
/**
* Creates a new poller.
*
* @param creator the items creator
* @param selector the selector to use for polling.
*/
public ZPoller(final ItemCreator creator, final Selector selector)
{
this.creator = creator;
this.selector = selector;
items = new HashMap>();
all = createContainer(0);
}
// creates a new poll item
protected ItemHolder create(final Socket socket, final EventsHandler handler, final int events)
{
assert (socket != null);
return creator.create(socket, handler, events);
}
// creates a new poll item
protected ItemHolder create(final SelectableChannel channel, final EventsHandler handler, final int events)
{
assert (channel != null);
return creator.create(channel, handler, events);
}
/**
* Sets the global events handler for all registered sockets.
*
* @param globalHandler the events handler to set
*/
public void setGlobalHandler(final EventsHandler globalHandler)
{
this.globalHandler = globalHandler;
}
/**
* Returns the global events handler for all registered sockets.
*
* @return the global events handler for all registered sockets.
*/
public EventsHandler getGlobalHandler()
{
return globalHandler;
}
/**
* Register a Socket for polling on specified events.
*
* @param socket the registering socket.
* @param handler the events handler for this socket
* @param events the events to listen to, as a mask composed by ORing POLLIN, POLLOUT and POLLERR.
* @return true if registered, otherwise false
*/
public final boolean register(final Socket socket,
final EventsHandler handler, final int events)
{
if (socket == null) {
return false;
}
return add(socket, create(socket, handler, events));
}
public final boolean register(final Socket socket, final EventsHandler handler)
{
return register(socket, handler, POLLIN | POLLOUT | POLLERR);
}
public final boolean register(final Socket socket, final int events)
{
return register(socket, globalHandler, events);
}
/**
* Register a SelectableChannel for polling on specified events.
*
* @param channel the registering channel.
* @param handler the events handler for this socket
* @param events the events to listen to, as a mask composed by XORing POLLIN, POLLOUT and POLLERR.
* @return true if registered, otherwise false
*/
public final boolean register(final SelectableChannel channel,
final EventsHandler handler, final int events)
{
if (channel == null) {
return false;
}
return add(channel, create(channel, handler, events));
}
public final boolean register(final SelectableChannel channel, final EventsHandler handler)
{
return register(channel, handler, IN | OUT | ERR);
}
public final boolean register(final SelectableChannel channel, final int events)
{
return register(channel, globalHandler, events);
}
/**
* Register an ItemHolder for polling on specified events.
*
* @param item the registering item.
* @return true if registered, otherwise false
*/
public final boolean register(final ItemHolder item)
{
return add(null, item);
}
/**
* Unregister a Socket or SelectableChannel for polling on the specified events.
*
* @param socketOrChannel the Socket or SelectableChannel to be unregistered
* @return true if unregistered, otherwise false
* TODO would it be useful to unregister only for specific events ?
*/
public final boolean unregister(final Object socketOrChannel)
{
if (socketOrChannel == null) {
return false;
}
Set items = this.items.remove(socketOrChannel);
boolean rc = items != null;
if (rc) {
all.removeAll(items);
}
return rc;
}
/******************************************************************************/
/* POLLING | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |*/
/******************************************************************************/
/**
* 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 timeout
* 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 "http://api.zeromq.org/3-0:zmq-poll"
*
* @return how many objects where signaled by poll ()
*/
public int poll(final long timeout)
{
return poll(timeout, true);
}
/**
* Issue a poll call, using the specified timeout value.
*
* @param timeout the timeout, as per zmq_poll ();
* @param dispatchEvents true to dispatch events using items handler and the global one.
* @see "http://api.zeromq.org/3-0:zmq-poll"
*
* @return how many objects where signaled by poll ()
*/
protected int poll(final long timeout, final boolean dispatchEvents)
{
// get all the raw items
final Collection all = items();
final Set pollItems = new HashSet(all.size());
for (ItemHolder holder : all) {
pollItems.add(holder.item());
}
// polling time
final int rc = poll(selector, timeout, pollItems);
if (!dispatchEvents) {
// raw result
return rc;
}
if (dispatch(all, pollItems.size())) {
// returns event counts after dispatch if everything went fine
return rc;
}
// error in dispatching
return -1;
}
// does the effective polling
protected int poll(final Selector selector, final long tout,
final Collection items)
{
final int size = items.size();
return zmq.ZMQ.poll(selector,
items.toArray(new zmq.PollItem[size]), size,
tout);
}
/**
* Dispatches the polled events.
*
* @param all the items used for dispatching
* @param size the number of items to dispatch
* @return true if correctly dispatched, false in case of error
*/
protected boolean dispatch(final Collection all, int size)
{
ItemHolder[] array = all.toArray(new ItemHolder[all.size()]);
// protected against handlers unregistering during this loop
for (ItemHolder holder : array) {
EventsHandler handler = holder.handler();
if (handler == null) {
handler = globalHandler;
}
if (handler == null) {
// no handler, short-circuit
continue;
}
final zmq.PollItem item = holder.item();
final int events = item.readyOps();
if (events <= 0) {
// no events, short-circuit
continue;
}
final Socket socket = holder.socket();
final SelectableChannel channel = holder.item().getRawSocket();
if (socket != null) {
assert (channel == null);
// dispatch on socket
if (!handler.events(socket, events)) {
return false;
}
}
if (channel != null) {
// dispatch on channel
assert (socket == null);
if (!handler.events(channel, events)) {
return false;
}
}
}
return true;
}
// dispatches all the polled events to their respective handlers
public boolean dispatch()
{
return dispatch(all, all.size());
}
/******************************************************************************/
/*| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | POLLING */
/******************************************************************************/
/**
* Tells if a channel is readable from this poller.
*
* @param channel the channel to ask for.
* @return true if readable, otherwise false
*/
public boolean isReadable(final SelectableChannel channel)
{
return readable((Object) channel);
}
public boolean readable(final SelectableChannel channel)
{
return readable((Object) channel);
}
/**
* Tells if a socket is readable from this poller.
*
* @param socket the socket to ask for.
* @return true if readable, otherwise false
*/
public boolean isReadable(final Socket socket)
{
return readable(socket);
}
public boolean readable(final Socket socket)
{
return readable((Object) socket);
}
// checks for read event
public boolean readable(final Object socketOrChannel)
{
final zmq.PollItem it = filter(socketOrChannel, IN);
if (it == null) {
return false;
}
return it.isReadable();
}
/**
* Tells if a channel is writable from this poller.
*
* @param channel the channel to ask for.
* @return true if writable, otherwise false
*/
public boolean isWritable(final SelectableChannel channel)
{
return writable((Object) channel);
}
public boolean writable(final SelectableChannel channel)
{
return writable((Object) channel);
}
/**
* Tells if a socket is writable from this poller.
*
* @param socket the socket to ask for.
* @return true if writable, otherwise false
*/
public boolean isWritable(final Socket socket)
{
return writable((Object) socket);
}
public boolean writable(final Socket socket)
{
return writable((Object) socket);
}
// checks for write event
public boolean writable(final Object socketOrChannel)
{
final zmq.PollItem it = filter(socketOrChannel, OUT);
if (it == null) {
return false;
}
return it.isWritable();
}
/**
* Tells if a channel is in error from this poller.
*
* @param channel the channel to ask for.
* @return true if in error, otherwise false
*/
public boolean isError(final SelectableChannel channel)
{
return error((Object) channel);
}
public boolean error(final SelectableChannel channel)
{
return error((Object) channel);
}
/**
* Tells if a socket is in error from this poller.
*
* @param socket the socket to ask for.
* @return true if in error, otherwise false
*/
public boolean isError(final Socket socket)
{
return error((Object) socket);
}
public boolean error(final Socket socket)
{
return error((Object) socket);
}
// checks for error event
public boolean error(final Object socketOrChannel)
{
final zmq.PollItem it = filter(socketOrChannel, ERR);
if (it == null) {
return false;
}
return it.isError();
}
/**
* Destroys the poller. Does actually nothing.
*/
@Override
public void close() throws IOException
{
// we didn't create the selector,
// it is not our responsibility to close it.
// selector.close();
}
/**
* Destroys the poller and the associated selector without exception.
*/
public void destroy()
{
try {
close();
}
catch (IOException e) {
e.printStackTrace();
}
}
// selector used for polling
private final Selector selector;
// creator of items
private final ItemCreator creator;
// managed items
private final Map> items;
// all managed items to avoid penalty cost when dispatching
private final Set all;
// TODO set of handlers, each with its specified events?
// optional global events handler
private EventsHandler globalHandler;
// simple creator for poll items
private static class SimpleCreator implements ItemCreator
{
@Override
public ItemHolder create(final Socket socket,
final EventsHandler handler, final int events)
{
return new ZPollItem(socket, handler, events);
}
@Override
public ItemHolder create(final SelectableChannel channel,
final EventsHandler handler, final int events)
{
return new ZPollItem(channel, handler, events);
}
}
// add an item to this poller
protected boolean add(Object socketOrChannel, final ItemHolder holder)
{
if (socketOrChannel == null) {
Socket socket = holder.socket();
SelectableChannel ch = holder.item().getRawSocket();
if (socket == null) {
// not a socket
assert (ch != null);
socketOrChannel = ch;
}
if (ch == null) {
// not a channel
assert (socket != null);
socketOrChannel = socket;
}
}
assert (socketOrChannel != null);
Set holders = items.get(socketOrChannel);
if (holders == null) {
holders = createContainer(1);
items.put(socketOrChannel, holders);
}
final boolean rc = holders.add(holder);
if (rc) {
all.add(holder);
}
return rc;
}
// create the container of holders
protected Set createContainer(int size)
{
return new HashSet(size);
}
// gets all the items of this poller
protected Collection items()
{
return all;
}
// gets all the items of this poller regarding the given input
protected Iterable items(final Object socketOrChannel)
{
final Set set = items.get(socketOrChannel);
if (set == null) {
return Collections.emptySet();
}
return set;
}
// filters items to get the first one matching the criteria, or null if none found
protected zmq.PollItem filter(final Object socketOrChannel, int events)
{
if (socketOrChannel == null) {
return null;
}
final Iterable items = items(socketOrChannel);
for (ItemHolder item : items) {
final zmq.PollItem it = item.item();
if ((it.interestOps() & events) > 0) {
return it;
}
}
return null;
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZProxy.java 0000664 0000000 0000000 00000112165 12551504772 0021710 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* Basic features:
*
* Remote Control
*
* Start: if was paused, flushes the pending messages
* Pause: lets the socket queues accumulate messages according to their types Stop: Shutdowns the proxy, can be restarted
* Status: Retrieves the status of the proxy
* Cold Restart: Closes and recreates the connections
* {@link #restart(ZMsg) Hot Restart}: User-defined behavior with custom messages
* {@link #configure(ZMsg) Configure}: User-defined behavior with custom messages
* {@link #command(String, boolean) ...}: Custom commands of your own
* Exit: Definitive shutdown of the proxy and its control
*
* All the non-custom commands can be performed in asynchronous or synchronous mode.
* Proxy mechanism ensured by pluggable pumps
*
* with built-in low-level {@link ZmqPump} (zmq.ZMQ): useful for performances
* with built-in high-level {@link ZPump} (ZeroMQ): useful for {@link ZPump.Transformer message transformation}, lower performances
* with your own-custom proxy pump implementing a {@link Pump 1-method interface}
*
*
*
* You can have all the above non-customizable features in about these lines of code:
*
*
* {@code
final ZProxy.Proxy provider = new ZProxy.SimpleProxy()
{
public Socket create(ZContext ctx, ZProxy.Plug place, Object[] args)
{
assert ("TEST".equals(args[0]);
Socket socket = null;
if (place == ZProxy.Plug.FRONT) {
socket = ctx.createSocket(ZMQ.ROUTER);
}
if (place == ZProxy.Plug.BACK) {
socket = ctx.createSocket(ZMQ.DEALER);
}
return socket;
}
public void configure(Socket socket, ZProxy.Plug place, Object[] args)
{
assert ("TEST".equals(args[0]);
int port = -1;
if (place == ZProxy.Plug.FRONT) {
port = socket.bind("tcp://127.0.0.1:6660");
}
if (place == ZProxy.Plug.BACK) {
port = socket.bind("tcp://127.0.0.1:6661");
}
if (place == ZProxy.Plug.CAPTURE && socket != null) {
socket.bind("tcp://127.0.0.1:4263");
}
}
};
ZProxy proxy = ZProxy.newProxy("ProxyOne", provider, "ABRACADABRA", Arrays.asList("TEST"));
}
*
* Once created, the proxy is not started. You have to perform first a start command on it.
* This choice was made because it is easier for a user to start it with one line of code than for the code to internally handle
* different possible starting states (after all, someone may want the proxy started but paused at first or configured in a specific way?)
* and because the a/sync stuff was funnier. Life is unfair ...
* Or maybe an idea is floating in the air?
*
* {@code
final boolean async = false, sync = true;
String status = null;
status = proxy.status();
status = proxy.pause(sync);
status = proxy.start(async);
ZMsg msg = proxy.restart(new ZMsg());
status = proxy.status(async);
status = proxy.stop(sync);
boolean here = proxy.sign();
ZMsg cfg = new ZMsg();
msg.add("CONFIG-1");
ZMsg rcvd = proxy.configure(cfg);
proxy.exit(async);
status = proxy.status(sync);
assert (!proxy.started());
}
*
*
* A {@link #command(Command, boolean) programmatic interface} with enums is also available.
*
*
*/
// Proxy for 0MQ.
public class ZProxy
{
/**
* Possible places for sockets in the proxy.
*/
public static enum Plug
{
FRONT, // The position of the frontend socket.
BACK, // The position of the backend socket.
CAPTURE; // The position of the capture socket.
}
// Contract for socket creation and customizable configuration in proxy threading.
public static interface Proxy
{
/**
* Creates and initializes (bind, options ...) the socket for the given plug in the proxy.
* The proxy will close them afterwards, and the context as well if not provided in the constructor.
* There is no need to keep a reference on the created socket or the context given in parameter.
*
* @param ctx the context used for initialization.
* @param place the position for the future created socket in the proxy.
* @param args the optional array of arguments that has been passed at the creation of the ZProxy.
* @return the created socket. Possibly null only for capture.
*/
Socket create(ZContext ctx, Plug place, Object[] args);
/**
* Configures the given socket.
*
* @param socket the socket to configure
* @param place the position for the socket in the proxy
* @param args the optional array of arguments that has been passed at the creation of the ZProxy.
*/
void configure(Socket socket, Plug place, Object[] args);
/**
* Performs a hot restart of the given socket.
* Usually an unbind/bind but you can use whatever method you like.
*
* @param cfg the custom configuration message sent by the control.
* @param socket the socket to hot restart
* @param place the position for the socket in the proxy
* @param args the optional array of arguments that has been passed at the creation of the ZProxy.
* @return true to perform a cold restart instead, false to do nothing. All the results will be collected from calls for all plugs.
* If any of them returns true, the cold restart is performed.
*/
boolean restart(ZMsg cfg, Socket socket, Plug place, Object[] args);
/**
* Configures the proxy with a custom message.
*
* Note: you need to send one (1) mandatory custom response message with the pipe before the end of this call.
*
* @param pipe the control pipe
* @param cfg the custom configuration message sent by the control
* @param frontend the frontend socket
* @param backend the backend socket
* @param capture the optional capture socket
* @param args the optional array of arguments that has been passed at the creation of the ZProxy.
* @return true to continue the proxy, false to exit
*/
boolean configure(Socket pipe, ZMsg cfg, Socket frontend, Socket backend,
Socket capture, Object[] args);
/**
* Handles a custom command not recognized by the proxy.
*
* Note: you need to send the current state at the end of the call.
*
* @param pipe the control pipe
* @param cmd the unrecognized command
* @param frontend the frontend socket
* @param backend the backend socket
* @param capture the optional capture socket
* @param args the optional array of arguments that has been passed at the creation of the ZProxy.
*
* @return true to continue the proxy, false to exit
*/
boolean custom(Socket pipe, String cmd, Socket frontend, Socket backend, Socket capture, Object[] args);
// this may be useful
public abstract static class SimpleProxy implements Proxy
{
@Override
public boolean restart(ZMsg cfg, Socket socket, Plug place,
Object[] args)
{
return true;
}
@Override
public boolean configure(Socket pipe, ZMsg cfg,
Socket frontend, Socket backend, Socket capture, Object[] args)
{
return true;
}
@Override
public boolean custom(Socket pipe, String cmd, Socket frontend, Socket backend, Socket capture, Object[] args)
{
return true;
}
}
}
/**
* Creates a new proxy in a ZeroMQ way.
* This proxy will be less efficient than the
* {@link #newZProxy(ZContext, String, org.zeromq.ZProxy.Proxy, String, Object...) low-level one}.
*
* @param ctx the context used for the proxy.
* Possibly null, in this case a new context will be created and automatically destroyed afterwards.
* @param name the name of the proxy. Possibly null.
* @param selector the creator of the selector used for the internal polling. Not null.
* @param sockets the sockets creator of the proxy. Not null.
* @param args an optional array of arguments that will be passed at the creation.
*
* @return the created proxy.
*/
// creates a new proxy
public static ZProxy newZProxy(ZContext ctx, String name,
SelectorCreator selector, Proxy sockets, String motdelafin, Object... args)
{
return new ZProxy(ctx, name, selector, sockets, new ZPump(), null, args);
}
public static ZProxy newZProxy(ZContext ctx, String name, Proxy sockets, String motdelafin, Object... args)
{
return new ZProxy(ctx, name, null, sockets, new ZPump(), motdelafin, args);
}
/**
* Creates a new low-level proxy for better performances.
*
* @param ctx the context used for the proxy.
* Possibly null, in this case a new context will be created and automatically destroyed afterwards.
* @param name the name of the proxy. Possibly null.
* @param selector the creator of the selector used for the internal polling. Not null.
* @param sockets the sockets creator of the proxy. Not null.
* @param args an optional array of arguments that will be passed at the creation.
*
* @return the created proxy.
*/
// creates a new low-level proxy
public static ZProxy newProxy(ZContext ctx, String name,
SelectorCreator selector, Proxy sockets, String motdelafin, Object... args)
{
return new ZProxy(ctx, name, selector, sockets, new ZmqPump(), motdelafin, args);
}
public static ZProxy newProxy(ZContext ctx, String name, Proxy sockets, String motdelafin, Object... args)
{
return new ZProxy(ctx, name, null, sockets, new ZmqPump(), motdelafin, args);
}
/**
* Starts the proxy.
*
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read status
*/
public String start(boolean sync)
{
return command(START, sync);
}
/**
* Pauses the proxy.
* A paused proxy will cease processing messages, causing
* them to be queued up and potentially hit the high-water mark on the
* frontend or backend socket, causing messages to be dropped, or writing
* applications to block.
*
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read status
*/
public String pause(boolean sync)
{
return command(PAUSE, sync);
}
/**
* Stops the proxy.
*
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read status
*/
public String stop(boolean sync)
{
return command(STOP, sync);
}
/**
* Sends a command message to the proxy actor.
* Can be useful for programmatic interfaces.
* Does not works with commands {@link #CONFIG CONFIG} and {@link #RESTART RESTART}.
*
* @param command the command to execute.
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read status
*/
public String command(String command, boolean sync)
{
assert (!command.equals(CONFIG));
assert (!command.equals(RESTART));
if (command.equals(STATUS)) {
return status(sync);
}
if (command.equals(EXIT)) {
return exit(sync);
}
// consume the status in the pipe
String status = recvStatus();
if (agent.send(command)) {
// the pipe is refilled
if (sync) {
status(true);
}
}
return status;
}
/**
* Sends a command message to the proxy actor.
* Can be useful for programmatic interfaces.
* Does not works with commands {@link Command#CONFIG CONFIG} and {@link Command#RESTART RESTART}.
*
* @param command the command to execute.
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read state
*/
public State command(Command command, boolean sync)
{
return State.valueOf(command(command.name(), sync));
}
/**
* Sends a command message to the proxy actor.
* Can be useful for programmatic interfaces.
* Works only with commands {@link Command#CONFIG CONFIG} and {@link Command#RESTART RESTART}.
*
* @param command the command to execute.
* @param msg the custom message to transmit.
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the response message
*/
public ZMsg command(Command command, ZMsg msg, boolean sync)
{
if (command == Command.CONFIG) {
return configure(msg);
}
if (command == Command.RESTART) {
String status = restart(msg);
msg = new ZMsg();
msg.add(status);
return msg;
}
return null;
}
/**
* Configures the proxy.
* The distant side has to send back one (1) mandatory response message.
*
* @param msg the custom message sent as configuration tip
* @return the mandatory response message of the configuration.
*/
public ZMsg configure(ZMsg msg)
{
msg.addFirst(CONFIG);
if (agent.send(msg)) {
// consume the status in the pipe
recvStatus();
ZMsg reply = agent.recv();
assert (reply != null);
// refill the pipe with status
agent.send(STATUS);
return reply;
}
return null;
}
/**
* Restarts the proxy. Stays alive.
*
* @param hot null to make a cold restart (closing then re-creation of the sockets)
* or a configuration message to perform a configurable hot restart,
*/
public String restart(ZMsg hot)
{
ZMsg msg = new ZMsg();
msg.add(RESTART);
if (hot == null) {
msg.add(Boolean.toString(false));
}
else {
msg.add(Boolean.toString(true));
// FIXME better way to append 1 message into another ?
for (int index = 0; index < hot.size(); ++index) {
ZFrame frame = hot.pop();
msg.add(frame);
}
}
String status = EXITED;
if (agent.send(msg)) {
status = status(false);
}
return status;
}
/**
* Stops the proxy and exits.
*
* @param sync true to read the status in synchronous way, false for asynchronous mode
* @return the read status
*/
public String exit(boolean sync)
{
String status = EXITED;
if (agent.send(EXIT)) {
if (sync) {
return await();
}
status = status(false);
}
return status;
}
// Waits for the completion of this proxy, like in old style.
private String await()
{
String status = status(true);
while (!Thread.currentThread().isInterrupted()) {
if (EXITED.equals(status)) {
break;
}
if (!agent.sign()) {
return EXITED;
}
status = status(false);
}
return status;
}
/**
* Inquires for the status of the proxy.
* This call is synchronous.
*/
public String status()
{
return status(true);
}
/**
* Inquires for the status of the proxy.
*
* @param sync true to read the status in synchronous way, false for asynchronous mode.
* If false, you get the last cached status of the proxy
*/
public String status(boolean sync)
{
String status = recvStatus();
if (agent.send(STATUS) && sync) {
// wait for the response to emulate sync
status = recvStatus();
// AND refill a status
if (!agent.send(STATUS)) {
// TODO and in case of error? Let's handle it with exception for now
throw new RuntimeException("Unable to send the status message");
}
}
return status;
}
// receives the last known state of the proxy
private String recvStatus()
{
if (!agent.sign()) {
return EXITED;
}
// receive the status response
final ZMsg msg = agent.recv();
if (msg == null) {
return EXITED;
}
String status = msg.popString();
msg.destroy();
return status;
}
/**
* Binary inquiry for the status of the proxy.
*/
public boolean isStarted()
{
return started();
}
/**
* Binary inquiry for the status of the proxy.
*/
public boolean started()
{
String status = status(true);
return STARTED.equals(status);
}
// to handle commands in a more java-centric way
public static enum Command
{
START,
PAUSE,
STOP,
RESTART,
EXIT,
STATUS,
CONFIG;
}
// commands for the control pipe
private static final String START = Command.START.name();
private static final String PAUSE = Command.PAUSE.name();
private static final String STOP = Command.STOP.name();
private static final String RESTART = Command.RESTART.name();
private static final String EXIT = Command.EXIT.name();
private static final String STATUS = Command.STATUS.name();
private static final String CONFIG = Command.CONFIG.name();
// to handle states in a more java-centric way
public static enum State
{
ALIVE,
STARTED,
PAUSED,
STOPPED,
EXITED;
}
// state responses from the control pipe
public static final String STARTED = State.STARTED.name();
public static final String PAUSED = State.PAUSED.name();
public static final String STOPPED = State.STOPPED.name();
public static final String EXITED = State.EXITED.name();
// defines the very first time where no command changing the state has been issued
public static final String ALIVE = State.ALIVE.name();
private static final AtomicInteger counter = new AtomicInteger();
// the endpoint to the distant proxy actor
private final ZAgent agent;
/**
* Creates a new unnamed proxy.
*
* @param selector the creator of the selector used for the proxy.
* @param creator the creator of the sockets of the proxy.
*/
public ZProxy(SelectorCreator selector, Proxy creator,
String motdelafin, Object ... args)
{
this(null, null, selector, creator, null, motdelafin, args);
}
/**
* Creates a new named proxy.
*
* @param name the name of the proxy (used in threads naming).
* @param selector the creator of the selector used for the proxy.
* @param creator the creator of the sockets of the proxy.
*/
public ZProxy(String name, SelectorCreator selector,
Proxy creator, String motdelafin, Object... args)
{
this(null, name, selector, creator, null, motdelafin, args);
}
/**
* Creates a new named proxy.
*
* @param ctx the main context used.
* If null, a new context will be created and closed at the stop of the operation.
* If not null, it is the responsibility of the call to close it.
* @param name the name of the proxy (used in threads naming).
* @param selector the creator of the selector used for the proxy.
* @param sockets the creator of the sockets of the proxy.
* @param pump the pump used for the proxy
*/
public ZProxy(ZContext ctx, String name, SelectorCreator selector,
Proxy sockets, Pump pump, String motdelafin, Object... args)
{
super();
// arguments parsing
if (pump == null) {
pump = new ZmqPump();
}
int count = 1;
count += args.length;
Object[] vars = null;
vars = new Object[count];
vars[0] = sockets;
Actor shadow = null;
// copy the arguments and retrieve the last optional shadow given in input
for (int index = 0; index < args.length; ++index) {
Object arg = args[index];
if (arg instanceof Actor) {
shadow = (Actor) arg;
}
vars[index + 1] = arg;
}
// handle the actor
int id = counter.incrementAndGet();
Actor actor = new ProxyActor(name, pump, id);
if (shadow != null) {
actor = new ZActor.Duo(actor, shadow);
}
ZActor zactor = new ZActor(ctx, selector, actor, motdelafin, vars);
agent = zactor.agent(); // the zactor is also its own agent
}
// defines a pump that will flow messages from one socket to another
public static interface Pump
{
/**
* Transfers a message from one source to one destination, with an optional capture.
*
* @param src the plug of the source socket
* @param source the socket where to receive the message from.
* @param capture the optional sockets where to send the message to. Possibly null.
* @param dst the plug of the destination socket
* @param destination the socket where to send the message to.
*
* @return false in case of error or interruption, true if successfully transferred the message
*/
boolean flow(Plug src, Socket source, Socket capture,
Plug dst, Socket destination);
}
// acts in background to proxy messages
private static final class ProxyActor extends ZActor.SimpleActor
{
// the states container of the proxy
private static final class State
{
// are we alive ?
private boolean alive = false;
// are we started ?
private boolean started = false;
// are we paused ?
private boolean paused = false;
// controls creation of a new agent if asked of a cold restart
private boolean restart = false;
// one-shot configuration for hot restart
private ZMsg hot;
}
// the state of the proxy
private final State state = new State();
// used to transfer message from one socket to another
private final Pump transport;
// the nice name of the proxy
private final String name;
// the provider of the sockets
private Proxy provider;
// the sockets creator user arguments
private Object[] args;
private Socket frontend;
private Socket backend;
private Socket capture;
// creates a new Proxy actor.
public ProxyActor(String name, Pump transport, int id)
{
if (name == null) {
// default basic name
this.name = String.format("ZProxy-%sd", id);
}
else {
this.name = name;
}
this.transport = transport;
}
@Override
public String premiere(Socket pipe)
{
return name;
}
// creates the sockets before the start of the proxy
@Override
public List createSockets(ZContext ctx, Object[] args)
{
provider = (Proxy) args[0];
this.args = new Object[args.length - 1];
System.arraycopy(args, 1, this.args, 0, this.args.length);
frontend = provider.create(ctx, Plug.FRONT, this.args);
capture = provider.create(ctx, Plug.CAPTURE, this.args);
backend = provider.create(ctx, Plug.BACK, this.args);
assert (frontend != null);
assert (backend != null);
return Arrays.asList(frontend, backend);
}
@Override
public void start(Socket pipe, List sockets, ZPoller poller)
{
// init the state machine
state.alive = true;
ZMsg reply = new ZMsg();
reply.add(ALIVE);
reply.send(pipe);
}
// Process a control message
@Override
public boolean backstage(Socket pipe, ZPoller poller, int events)
{
assert (state.hot == null);
String cmd = pipe.recvStr();
// a message has been received from the API
if (START.equals(cmd)) {
start(poller);
return status().send(pipe);
}
else if (STOP.equals(cmd)) {
stop(poller);
return status().send(pipe);
}
else if (PAUSE.equals(cmd)) {
pause(poller, true);
return status().send(pipe);
}
else if (RESTART.equals(cmd)) {
String val = pipe.recvStr();
boolean hot = Boolean.parseBoolean(val);
return restart(pipe, poller, hot);
}
else if (STATUS.equals(cmd)) {
return status().send(pipe);
}
else if (CONFIG.equals(cmd)) {
ZMsg cfg = ZMsg.recvMsg(pipe);
boolean rc = provider.configure(pipe, cfg, frontend, backend, capture, args);
cfg.destroy();
return rc;
}
else if (EXIT.equals(cmd)) {
// stops the proxy and the agent.
// the status will be sent at the end of the loop
}
else {
return provider.custom(pipe, cmd, frontend, backend, capture, args);
}
return false;
}
// returns the status
private ZMsg status()
{
ZMsg reply = new ZMsg();
if (!state.alive) {
reply.add(EXITED);
return reply;
}
if (state.started) {
if (state.paused) {
reply.add(PAUSED);
}
else {
reply.add(STARTED);
}
}
else {
reply.add(STOPPED);
}
return reply;
}
// starts the proxy sockets
private boolean start(ZPoller poller)
{
if (!state.started) {
state.started = true;
provider.configure(frontend, Plug.FRONT, args);
provider.configure(backend, Plug.BACK, args);
provider.configure(capture, Plug.CAPTURE, args);
}
if (!state.paused) {
pause(poller, false);
}
return true;
}
// pauses the proxy sockets
private boolean pause(ZPoller poller, boolean pause)
{
state.paused = pause;
if (pause) {
poller.unregister(frontend);
poller.unregister(backend);
// TODO why not a mechanism for eventually flushing the sockets during the pause?
}
else {
poller.register(frontend, ZPoller.POLLIN);
poller.register(backend, ZPoller.POLLIN);
// Now Wait also until there are either requests or replies to process.
}
return true;
}
private boolean stop(ZPoller poller)
{
// restart the actor in stopped state
state.started = false;
// close connections
state.restart = true;
return true;
}
// handles the restart command in both modes
private boolean restart(Socket pipe, ZPoller poller, boolean hot)
{
if (hot) {
assert (provider != null);
state.hot = ZMsg.recvMsg(pipe);
state.restart = true;
// continue with the same agent
return true;
}
else {
state.restart = true;
// stop the loop and restart a new agent
// with the same started state
// the next loop will refill the updated status
return false;
}
}
@Override
public long looping(Socket pipe, ZPoller poller)
{
state.hot = null;
return super.looping(pipe, poller);
}
// a message has been received for the proxy to process
@Override
public boolean stage(Socket socket, Socket pipe, ZPoller poller,
int events)
{
if (socket == frontend) {
// Process a request.
return transport.flow(
Plug.FRONT, frontend,
capture,
Plug.BACK, backend);
}
if (socket == backend) {
// Process a reply.
return transport.flow(
Plug.BACK, backend,
capture,
Plug.FRONT, frontend);
}
return false;
}
@Override
public boolean looped(Socket pipe, ZPoller poller)
{
if (state.restart && state.hot != null) {
// caught the hot restart
ZMsg cfg = state.hot;
state.hot = null;
state.restart = false;
boolean cold;
ZMsg dup = cfg.duplicate();
cold = provider.restart(dup, frontend, Plug.FRONT, this.args);
dup.destroy();
dup = cfg.duplicate();
cold |= provider.restart(dup, backend, Plug.BACK, this.args);
dup.destroy();
dup = cfg.duplicate();
cold |= provider.restart(dup, capture, Plug.CAPTURE, this.args);
dup.destroy();
cfg.destroy();
// we perform a cold restart if the provider says so
state.restart = cold;
}
return true;
}
// called in the proxy thread when it stopped.
@Override
public boolean destroyed(Socket pipe, ZPoller poller)
{
if (capture != null) {
capture.close();
}
if (!state.restart) {
state.alive = false;
status().send(pipe);
}
return state.restart;
}
}
/**
* A pump that reads a message as a whole before transmitting it.
* It offers a way to transform messages for capture and destination.
*/
public static class ZPump implements Pump
{
private static final Identity IDENTITY = new Identity();
// the messages transformer
private final Transformer transformer;
// transforms one message into another
public static interface Transformer
{
/**
* Transforms a ZMsg into another ZMsg.
* Please note that this will be used during the message transfer,
* so lengthy operations will have a cost on performances by definition.
* If you return back another message than the one given in input, then this one has to be destroyed by you.
* @param msg the message to transform
* @param src the source plug
* @param dst the destination plug
* @return the transformed message
*/
ZMsg transform(ZMsg msg, Plug src, Plug dst);
}
private static class Identity implements Transformer
{
@Override
public ZMsg transform(ZMsg msg, Plug src, Plug dst)
{
return msg;
}
}
public ZPump()
{
this(null);
}
public ZPump(Transformer transformer)
{
super();
this.transformer = transformer == null ? IDENTITY : transformer;
}
@Override
public boolean flow(Plug splug, Socket source, Socket capture,
Plug dplug, Socket destination)
{
boolean success = false;
// we read the whole message
ZMsg msg = ZMsg.recvMsg(source);
if (msg == null) {
return false;
}
if (capture != null) {
// Copy transformed message to capture socket if any message
// TODO what if the transformer modifies or destroys the original message ?
ZMsg cpt = transformer.transform(msg, splug, Plug.CAPTURE);
// boolean destroy = !msg.equals(cpt); // TODO ?? which one
boolean destroy = msg != cpt;
success = cpt.send(capture, destroy);
if (!success) {
// not successful, but we can still try to send it to the destination
}
}
ZMsg dst = transformer.transform(msg, splug, dplug);
// we send the whole transformed message
success = dst.send(destination);
// finished
msg.destroy();
return success;
}
}
/**
* A specialized transport for better transmission purposes
* that will send each packets individually instead of the whole message.
*/
private static final class ZmqPump implements Pump
{
// transfers each message as a whole by sending each packet received to the capture socket
@Override
public boolean flow(Plug splug, Socket source, Socket capture,
Plug dplug, Socket destination)
{
boolean rc;
SocketBase src = source.base();
SocketBase dst = destination.base();
SocketBase cpt = capture == null ? null : capture.base();
// we transfer the whole message
while (true) {
// we read the packet
Msg msg = src.recv(0);
if (msg == null) {
return false;
}
long more = src.getSocketOpt(zmq.ZMQ.ZMQ_RCVMORE);
if (more < 0) {
return false;
}
// Copy message to capture socket if any packet
if (cpt != null) {
Msg ctrl = new Msg(msg);
rc = cpt.send(ctrl, more > 0 ? zmq.ZMQ.ZMQ_SNDMORE : 0);
if (!rc) {
// not successful, but we can still try to send it to the destination
}
}
// we send the packet
rc = dst.send(msg, more > 0 ? zmq.ZMQ.ZMQ_SNDMORE : 0);
if (!rc) {
return false;
}
if (more == 0) {
break;
}
}
return true;
}
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZStar.java 0000664 0000000 0000000 00000050412 12551504772 0021474 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
* A side or endpoint designates the same thing: the thread where lives one of the two parts of the system.
*
* - the Plateau side, or background side where all the performances are made by the provided star.
*
* Communication between the 2 sides is ensured by {@link #pipe() pipes} that SHALL NEVER be mixed between background and control sides.
*
* The ZStar takes care of the establishment of the background processing, calling the provided star
* at appropriate times. It can also manage the {@link ZAgent#sign() exited} state on the control side,
* if providing a non-null "Mot de la Fin".
*
* A {@link Star star} is basically a contract interface that anyone who uses this ZStar to create a background service SHALL comply to.
* PS: Je sais qu'il y a une différence entre acteur et comédien :)
* PPS: I know nothing about theater!
*
* For an example of code, please refer to the {@link ZActor} source code.
*
*/
// remote controlled background message processing API for 0MQ.
public class ZStar implements ZAgent
{
/**
* Contract interface when acting in plain sight.
*/
// contract interface for acting with the spot lights on
public static interface Star
{
/**
* Called when the star is in the wings.If not null, it is the responsibility of the caller to close it.
*
* @param selector the creator of the selector used on the Plateau.
* @param fortune the creator of stars on the Plateau
* @param motdelafin the final word used to mark the end of the star. Null to disable this mechanism.
* @param bags the optional arguments that will be passed to the distant star
*/
public ZStar(final ZContext context, final SelectorCreator selector,
final Fortune fortune, String motdelafin, final Object[] bags)
{
super();
assert (fortune != null);
// entering platform to load trucks
// the story writer
SelectorCreator feather = selector;
if (selector == null) {
// initialize selector
feather = new VerySimpleSelectorCreator();
}
// initialize the context
ZContext chef = context;
ZContext producer = null;
if (chef == null) {
// no context provided, create one
chef = new ZContext();
// it will be destroyed, so this is the main context
producer = chef;
}
// retrieve the last optional set and entourage given in input
Set set = null;
Entourage entourage = null;
for (Object bag : bags) {
if (bag instanceof Set) {
set = (Set) bag;
}
if (bag instanceof Entourage) {
entourage = (Entourage) bag;
}
}
if (set == null) {
set = new SimpleSet();
}
final List train = new ArrayList(6 + bags.length);
train.add(set);
train.add(fortune);
train.add(feather);
train.add(producer);
train.add(entourage);
train.add(motdelafin);
// 6 mandatory wagons
train.addAll(Arrays.asList(bags));
// now going to the plateau
Socket phone = ZThread.fork(chef, new Plateau(), train.toArray());
agent = agent(phone, motdelafin);
}
// communicating agent with the star for the Corbeille side
private final ZAgent agent;
/**
* Creates a new agent for the star.
*
* This method is called in the constructor so don't rely on private members to do the job.
* Apart from that, it is the last call so can be safely overridden from the ZStar point-of-view
* BUT if you don't make it final, one of your subclass could make you misery...
*
* @param phone the socket used to communicate with the star
* @param secret the specific keyword indicating the death of the star and locking the agent. Null to override the lock mechanism.
* @return the newly created agent for the star.
*/
protected ZAgent agent(Socket phone, String secret)
{
return ZAgent.Creator.create(phone, secret);
}
// the plateau where the acting will take place (stage and backstage), or
// the forked runnable containing the loop processing all messages in the background
private static final class Plateau implements IAttachedRunnable
{
private static final AtomicInteger shows = new AtomicInteger();
// id if unnamed
private final int number = shows.incrementAndGet();
@Override
public void run(final Object[] train,
final ZContext chef,
final Socket mic)
{
final int mandat = 6;
// end of a trip can be a bit messy...
Fortune star = (Fortune) train[1];
final Entourage entourage = (Entourage) train[4];
final ZContext producer = (ZContext) train[3];
final SelectorCreator feather = (SelectorCreator) train[2];
final Set set = (Set) train[0];
// the word informing the world that the plateau is closed and the star vanished
final String gossip = (String) train[5];
// prune our mandatory transit variables from the arguments
final Object[] bags = new Object[train.length - mandat];
System.arraycopy(train, mandat, bags, 0, bags.length);
// leaving unloaded platform
if (entourage != null) {
entourage.breakaleg(chef, star, mic, bags);
}
Selector story = null;
// now entering artistic zone
try {
// create the selector used for polling operations
story = feather.create();
// Premiere !
String name = star.premiere(mic, bags);
// put the name of the performance on the front door with lightnings
set.lights(name, number);
// star is entering the wings
showMustGoOn(chef, set, story, mic, star, bags);
// star is leaving the plateau
}
catch (IOException e) {
// Who stole the story? There is no play if there is no story! C'est un scandale!
e.printStackTrace();
// TODO enhance error
}
finally {
// star is interviewed about this event
boolean tell = star.interview(mic);
if (tell && gossip != null) {
// inform the Corbeille side of the future closing of the plateau and the vanishing of the star
mic.send(gossip);
}
// we are not in a hurry at this point when cleaning up the remains of a good show ...
star.party(chef);
star = null;
if (entourage != null) {
entourage.party(chef);
}
// Sober again ...
// show is over, time to close
chef.close();
if (producer != null) {
// this is a self-generated context, destroy it
producer.close();
}
try {
feather.destroy(story);
}
catch (IOException e) {
// really ?
e.printStackTrace();
}
}
}
/******************************************************************************/
/* TAP TAP TAP | | TAP | | TAP | | TAP | | | | | | | | | | | | | | | | | | | |*/
/******************************************************************************/
// starts the performance
private void showMustGoOn(final ZContext chef, final Set set, final Selector story,
final Socket phone, final Fortune fortune, final Object[] bags)
{
int shows = 0;
/** on the spot lights, the star in only an actor **/
Star actor = null;
/** double-while-loop enables the restarting of a new star for the same acting on the same stage **/
/// so existing sockets can be closed and recreated in order to perform a cold restart or a stop **/
do {
actor = fortune.create(chef, phone, story, shows++, actor, bags);
/** a new star is born! And an acting one! **/
actor.prepare();
/** actor is leaving the wings **/
while (!set.fire()) {
/** actor decides when the act will begin **/
int events = actor.breathe();
/** perform a new act of the show **/
if (!actor.act(events)) {
// Context has been shut down
break;
}
/** end of the act, back to the wings **/
if (!actor.entract()) {
// star has decided to stop acting
break;
}
}
}
while (actor.renews());
// star is leaving the Plateau and the show
}
/******************************************************************************/
/* | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |*/
/******************************************************************************/
// NB: never use green color on the stage floor of a french theater. Or something bad will happen...
}
@Override
public ZMsg recv()
{
return agent.recv();
}
@Override
public ZMsg recv(boolean wait)
{
return agent.recv(wait);
}
@Override
public boolean send(ZMsg message)
{
return agent.send(message);
}
@Override
public boolean send(ZMsg msg, boolean destroy)
{
return agent.send(msg, destroy);
}
@Override
public boolean send(String word)
{
return agent.send(word);
}
@Override
public boolean send(String word, boolean more)
{
return agent.send(word, more);
}
@Override
public Socket pipe()
{
return agent.pipe();
}
@Override
public boolean sign()
{
return agent.sign();
}
@Override
public void nova()
{
agent.nova();
}
public static interface Set
{
/**
* Puts the performance name on the front door with big lights.
* @param name the name of the performance.
* @param id the performance number.
*/
void lights(String name, int id);
/**
* Is the set on fire ?
* @return true if it is time to leave the place.
*/
boolean fire();
}
public static class SimpleSet implements Set
{
@Override
public boolean fire()
{
return Thread.currentThread().isInterrupted();
}
@Override
public void lights(String name, int id)
{
if (name == null) {
name = createDefaultName("Star-%d", id);
}
Thread.currentThread().setName(name);
}
public static String createDefaultName(final String format, final int id)
{
return String.format(format, id);
}
}
/**
* Utility class with calls surrounding the execution of the Star.
*/
public static interface Entourage extends TimeTaker
{
/**
* Called when the show is about to start.
* Can be a useful point in the whole process from time to time.
*
* @param ctx the context provided in the creation step
* @param fortune the creator of stars
* @param phone the socket used to communicate with the Agent
* @param bags the optional arguments that were passed at the creation
*/
void breakaleg(ZContext ctx, Fortune fortune, Socket phone, Object[] bags);
// well ...
}
}
jeromq-0.3.5/src/main/java/org/zeromq/ZThread.java 0000664 0000000 0000000 00000007245 12551504772 0022000 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 sockets;
// List of unused thread slots.
private final Deque emptySlots;
// If true, init has been called but no socket has been created
// yet. Launching of I/O threads is delayed.
private AtomicBoolean starting = new AtomicBoolean(true);
// If true, zmq_term was already called.
private boolean terminating;
// Synchronisation of accesses to global slot-related data:
// sockets, emptySlots, terminating. It also synchronises
// access to zombie sockets as such (as opposed to slots) and provides
// a memory barrier to ensure that all CPU cores see the same data.
private final Lock slotSync;
// The reaper thread.
private Reaper reaper;
// I/O threads.
private final List ioThreads;
// Array of pointers to mailboxes for both application and I/O threads.
private int slotCount;
private Mailbox[] slots;
// Mailbox for zmq_term thread.
private final Mailbox termMailbox;
// List of inproc endpoints within this context.
private final Map endpoints;
// Synchronisation of access to the list of inproc endpoints.
private final Lock endpointsSync;
// Maximum socket ID.
private static AtomicInteger maxSocketId = new AtomicInteger(0);
// Maximum number of sockets that can be opened at the same time.
private int maxSockets;
// Number of I/O threads to launch.
private int ioThreadCount;
// Does context wait (possibly forever) on termination?
private boolean blocky;
// Synchronisation of access to context options.
private final Lock optSync;
public static final int TERM_TID = 0;
public static final int REAPER_TID = 1;
public Ctx()
{
tag = 0xabadcafe;
terminating = false;
reaper = null;
slotCount = 0;
slots = null;
maxSockets = ZMQ.ZMQ_MAX_SOCKETS_DFLT;
ioThreadCount = ZMQ.ZMQ_IO_THREADS_DFLT;
blocky = true;
slotSync = new ReentrantLock();
endpointsSync = new ReentrantLock();
optSync = new ReentrantLock();
termMailbox = new Mailbox("terminater");
emptySlots = new ArrayDeque();
ioThreads = new ArrayList();
sockets = new ArrayList();
endpoints = new HashMap();
}
private void destroy() throws IOException
{
for (IOThread it : ioThreads) {
it.stop();
}
for (IOThread it : ioThreads) {
it.close();
}
if (reaper != null) {
reaper.close();
}
termMailbox.close();
tag = 0xdeadbeef;
}
// Returns false if object is not a context.
public boolean checkTag()
{
return tag == 0xabadcafe;
}
// This function is called when user invokes zmq_term. If there are
// no more sockets open it'll cause all the infrastructure to be shut
// down. If there are open sockets still, the deallocation happens
// after the last one is closed.
public void terminate()
{
tag = 0xdeadbeef;
if (!starting.get()) {
slotSync.lock();
try {
// Check whether termination was already underway, but interrupted and now
// restarted.
boolean restarted = terminating;
terminating = true;
// First attempt to terminate the context.
if (!restarted) {
// First send stop command to sockets so that any blocking calls
// can be interrupted. If there are no sockets we can ask reaper
// thread to stop.
for (SocketBase socket : sockets) {
socket.stop();
}
if (sockets.isEmpty()) {
reaper.stop();
}
}
}
finally {
slotSync.unlock();
}
// Wait till reaper thread closes all the sockets.
Command cmd = termMailbox.recv(-1);
if (cmd == null) {
throw new IllegalStateException();
}
assert (cmd.type() == Command.Type.DONE);
slotSync.lock();
try {
assert (sockets.isEmpty());
}
finally {
slotSync.unlock();
}
}
// Deallocate the resources.
try {
destroy();
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
public boolean set(int option, int optval)
{
if (option == ZMQ.ZMQ_MAX_SOCKETS && optval >= 1) {
optSync.lock();
try {
maxSockets = optval;
}
finally {
optSync.unlock();
}
}
else
if (option == ZMQ.ZMQ_IO_THREADS && optval >= 0) {
optSync.lock();
try {
ioThreadCount = optval;
}
finally {
optSync.unlock();
}
}
else
if (option == ZMQ.ZMQ_BLOCKY && optval >= 0) {
optSync.lock();
try {
blocky = (optval != 0);
}
finally {
optSync.unlock();
}
}
else {
return false;
}
return true;
}
public int get(int option)
{
int rc = 0;
if (option == ZMQ.ZMQ_MAX_SOCKETS) {
rc = maxSockets;
}
else if (option == ZMQ.ZMQ_IO_THREADS) {
rc = ioThreadCount;
}
else if (option == ZMQ.ZMQ_BLOCKY) {
rc = blocky ? 1 : 0;
}
else {
throw new IllegalArgumentException("option = " + option);
}
return rc;
}
public SocketBase createSocket(int type)
{
SocketBase s = null;
slotSync.lock();
try {
if (starting.compareAndSet(true, false)) {
// Initialize the array of mailboxes. Additional three slots are for
// zmq_term thread and reaper thread.
int mazmq;
int ios;
optSync.lock();
try {
mazmq = maxSockets;
ios = ioThreadCount;
}
finally {
optSync.unlock();
}
slotCount = mazmq + ios + 2;
slots = new Mailbox[slotCount];
//alloc_assert (slots);
// Initialize the infrastructure for zmq_term thread.
slots[TERM_TID] = termMailbox;
// Create the reaper thread.
reaper = new Reaper(this, REAPER_TID);
//alloc_assert (reaper);
slots[REAPER_TID] = reaper.getMailbox();
reaper.start();
// Create I/O thread objects and launch them.
for (int i = 2; i != ios + 2; i++) {
IOThread ioThread = new IOThread(this, i);
//alloc_assert (io_thread);
ioThreads.add(ioThread);
slots[i] = ioThread.getMailbox();
ioThread.start();
}
// In the unused part of the slot array, create a list of empty slots.
for (int i = (int) slotCount - 1;
i >= (int) ios + 2; i--) {
emptySlots.add(i);
slots[i] = null;
}
}
// Once zmq_term() was called, we can't create new sockets.
if (terminating) {
throw new ZError.CtxTerminatedException();
}
// If maxSockets limit was reached, return error.
if (emptySlots.isEmpty()) {
throw new IllegalStateException("EMFILE");
}
// Choose a slot for the socket.
int slot = emptySlots.pollLast();
// Generate new unique socket ID.
int sid = maxSocketId.incrementAndGet();
// Create the socket and register its mailbox.
s = SocketBase.create(type, this, slot, sid);
if (s == null) {
emptySlots.addLast(slot);
return null;
}
sockets.add(s);
slots[slot] = s.getMailbox();
}
finally {
slotSync.unlock();
}
return s;
}
public void destroySocket(SocketBase socket)
{
slotSync.lock();
// Free the associated thread slot.
try {
int tid = socket.getTid();
emptySlots.add(tid);
slots[tid] = null;
// Remove the socket from the list of sockets.
sockets.remove(socket);
// If zmq_term() was already called and there are no more socket
// we can ask reaper thread to terminate.
if (terminating && sockets.isEmpty()) {
reaper.stop();
}
}
finally {
slotSync.unlock();
}
}
// Returns reaper thread object.
ZObject getReaper()
{
return reaper;
}
// Send command to the destination thread.
void sendCommand(int tid, final Command command)
{
slots[tid].send(command);
}
// Returns the I/O thread that is the least busy at the moment.
// Affinity specifies which I/O threads are eligible (0 = all).
// Returns NULL if no I/O thread is available.
IOThread chooseIoThread(long affinity)
{
if (ioThreads.isEmpty()) {
return null;
}
// Find the I/O thread with minimum load.
int minLoad = -1;
IOThread selectedIoThread = null;
for (int i = 0; i != ioThreads.size(); i++) {
if (affinity == 0 || (affinity & (1L << i)) > 0) {
int load = ioThreads.get(i).getLoad();
if (selectedIoThread == null || load < minLoad) {
minLoad = load;
selectedIoThread = ioThreads.get(i);
}
}
}
return selectedIoThread;
}
// Management of inproc endpoints.
boolean registerEndpoint(String addr, Endpoint endpoint)
{
endpointsSync.lock();
Endpoint inserted = null;
try {
inserted = endpoints.put(addr, endpoint);
}
finally {
endpointsSync.unlock();
}
if (inserted != null) {
return false;
}
return true;
}
void unregisterEndpoints(SocketBase socket)
{
endpointsSync.lock();
try {
Iterator> it = endpoints.entrySet().iterator();
while (it.hasNext()) {
Entry e = it.next();
if (e.getValue().socket == socket) {
it.remove();
}
}
}
finally {
endpointsSync.unlock();
}
}
Endpoint findEndpoint(String addr)
{
Endpoint endpoint = null;
endpointsSync.lock();
try {
endpoint = endpoints.get(addr);
if (endpoint == null) {
//ZError.errno(ZError.ECONNREFUSED);
return new Endpoint(null, new Options());
}
// Increment the command sequence number of the peer so that it won't
// get deallocated until "bind" command is issued by the caller.
// The subsequent 'bind' has to be called with inc_seqnum parameter
// set to false, so that the seqnum isn't incremented twice.
endpoint.socket.incSeqnum();
}
finally {
endpointsSync.unlock();
}
return endpoint;
}
}
jeromq-0.3.5/src/main/java/zmq/Dealer.java 0000664 0000000 0000000 00000007236 12551504772 0020336 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pipes_t;
private final List pipes;
// Number of all the pipes to send the next message to.
private int matching;
// Number of active pipes. All the active pipes are located at the
// beginning of the pipes array. These are the pipes the messages
// can be sent to at the moment.
private int active;
// Number of pipes eligible for sending messages to. This includes all
// the active pipes plus all the pipes that we can in theory send
// messages to (the HWM is not yet reached), but sending a message
// to them would result in partial message being delivered, ie. message
// with initial parts missing.
private int eligible;
// True if last we are in the middle of a multipart message.
private boolean more;
public Dist()
{
matching = 0;
active = 0;
eligible = 0;
more = false;
pipes = new ArrayList();
}
// Adds the pipe to the distributor object.
public void attach(Pipe pipe)
{
// If we are in the middle of sending a message, we'll add new pipe
// into the list of eligible pipes. Otherwise we add it to the list
// of active pipes.
if (more) {
pipes.add(pipe);
//pipes.swap (eligible, pipes.size() - 1);
Utils.swap(pipes, eligible, pipes.size() - 1);
eligible++;
}
else {
pipes.add(pipe);
//pipes.swap (active, pipes.size() - 1);
Utils.swap(pipes, active, pipes.size() - 1);
active++;
eligible++;
}
}
// Mark the pipe as matching. Subsequent call to sendToMatching
// will send message also to this pipe.
public void match(Pipe pipe)
{
int idx = pipes.indexOf(pipe);
// If pipe is already matching do nothing.
if (idx < matching) {
return;
}
// If the pipe isn't eligible, ignore it.
if (idx >= eligible) {
return;
}
// Mark the pipe as matching.
Utils.swap(pipes, idx, matching);
matching++;
}
// Mark all pipes as non-matching.
public void unmatch()
{
matching = 0;
}
// Removes the pipe from the distributor object.
public void terminated(Pipe pipe)
{
// Remove the pipe from the list; adjust number of matching, active and/or
// eligible pipes accordingly.
if (pipes.indexOf(pipe) < matching) {
Utils.swap(pipes, pipes.indexOf(pipe), matching - 1);
matching--;
}
if (pipes.indexOf(pipe) < active) {
Utils.swap(pipes, pipes.indexOf(pipe), active - 1);
active--;
}
if (pipes.indexOf(pipe) < eligible) {
Utils.swap(pipes, pipes.indexOf(pipe), eligible - 1);
eligible--;
}
pipes.remove(pipe);
}
// Activates pipe that have previously reached high watermark.
public void activated(Pipe pipe)
{
// Move the pipe from passive to eligible state.
Utils.swap(pipes, pipes.indexOf(pipe), eligible);
eligible++;
// If there's no message being sent at the moment, move it to
// the active state.
if (!more) {
Utils.swap(pipes, eligible - 1, active);
active++;
}
}
// Send the message to all the outbound pipes.
public boolean sendToAll(Msg msg)
{
matching = active;
return sendToMatching(msg);
}
// Send the message to the matching outbound pipes.
public boolean sendToMatching(Msg msg)
{
// Is this end of a multipart message?
boolean msgMore = msg.hasMore();
// Push the message to matching pipes.
distribute(msg);
// If mutlipart message is fully sent, activate all the eligible pipes.
if (!msgMore) {
active = eligible;
}
more = msgMore;
return true;
}
// Put the message to all active pipes.
private void distribute(Msg msg)
{
// If there are no matching pipes available, simply drop the message.
if (matching == 0) {
return;
}
for (int i = 0; i < matching; ++i) {
if (!write(pipes.get(i), msg)) {
--i; // Retry last write because index will have been swapped
}
}
}
public boolean hasOut()
{
return true;
}
// Write the message to the pipe. Make the pipe inactive if writing
// fails. In such a case false is returned.
private boolean write(Pipe pipe, Msg msg)
{
if (!pipe.write(msg)) {
Utils.swap(pipes, pipes.indexOf(pipe), matching - 1);
matching--;
Utils.swap(pipes, pipes.indexOf(pipe), active - 1);
active--;
Utils.swap(pipes, active, eligible - 1);
eligible--;
return false;
}
if (!msg.hasMore()) {
pipe.flush();
}
return true;
}
}
jeromq-0.3.5/src/main/java/zmq/Encoder.java 0000664 0000000 0000000 00000006234 12551504772 0020516 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pipes;
// Number of active pipes. All the active pipes are located at the
// beginning of the pipes array.
private int active;
// Index of the next bound pipe to read a message from.
private int current;
// If true, part of a multipart message was already received, but
// there are following parts still waiting in the current pipe.
private boolean more;
public FQ()
{
active = 0;
current = 0;
more = false;
pipes = new ArrayList();
}
public void attach(Pipe pipe)
{
pipes.add(pipe);
Utils.swap(pipes, active, pipes.size() - 1);
active++;
}
public void terminated(Pipe pipe)
{
final int index = pipes.indexOf(pipe);
// Remove the pipe from the list; adjust number of active pipes
// accordingly.
if (index < active) {
active--;
Utils.swap(pipes, index, active);
if (current == active) {
current = 0;
}
}
pipes.remove(pipe);
}
public void activated(Pipe pipe)
{
// Move the pipe to the list of active pipes.
Utils.swap(pipes, pipes.indexOf(pipe), active);
active++;
}
public Msg recv(ValueReference errno)
{
return recvPipe(errno, null);
}
public Msg recvPipe(ValueReference errno, ValueReference pipe)
{
// Round-robin over the pipes to get the next message.
while (active > 0) {
// Try to fetch new message. If we've already read part of the message
// subsequent part should be immediately available.
Msg msg = pipes.get(current).read();
boolean fetched = msg != null;
// Note that when message is not fetched, current pipe is deactivated
// and replaced by another active pipe. Thus we don't have to increase
// the 'current' pointer.
if (fetched) {
if (pipe != null) {
pipe.set(pipes.get(current));
}
more = msg.hasMore();
if (!more) {
current = (current + 1) % active;
}
return msg;
}
// Check the atomicity of the message.
// If we've already received the first part of the message
// we should get the remaining parts without blocking.
assert (!more);
active--;
Utils.swap(pipes, current, active);
if (current == active) {
current = 0;
}
}
// No message is available. Initialise the output parameter
// to be a 0-byte message.
errno.set(ZError.EAGAIN);
return null;
}
public boolean hasIn()
{
// There are subsequent parts of the partly-read message available.
if (more) {
return true;
}
// Note that messing with current doesn't break the fairness of fair
// queueing algorithm. If there are no messages available current will
// get back to its original value. Otherwise it'll point to the first
// pipe holding messages, skipping only pipes with no messages available.
while (active > 0) {
if (pipes.get(current).checkRead()) {
return true;
}
// Deactivate the pipe.
active--;
Utils.swap(pipes, current, active);
if (current == active) {
current = 0;
}
}
return false;
}
}
jeromq-0.3.5/src/main/java/zmq/IDecoder.java 0000664 0000000 0000000 00000001762 12551504772 0020616 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pipes;
// Number of active pipes. All the active pipes are located at the
// beginning of the pipes array.
private int active;
// Points to the last pipe that the most recent message was sent to.
private int current;
// True if last we are in the middle of a multipart message.
private boolean more;
// True if we are dropping current message.
private boolean dropping;
public LB()
{
active = 0;
current = 0;
more = false;
dropping = false;
pipes = new ArrayList();
}
public void attach(Pipe pipe)
{
pipes.add(pipe);
activated(pipe);
}
public void terminated(Pipe pipe)
{
int index = pipes.indexOf(pipe);
// If we are in the middle of multipart message and current pipe
// have disconnected, we have to drop the remainder of the message.
if (index == current && more) {
dropping = true;
}
// Remove the pipe from the list; adjust number of active pipes
// accordingly.
if (index < active) {
active--;
Utils.swap(pipes, index, active);
if (current == active) {
current = 0;
}
}
pipes.remove(pipe);
}
public void activated(Pipe pipe)
{
// Move the pipe to the list of active pipes.
Utils.swap(pipes, pipes.indexOf(pipe), active);
active++;
}
public boolean send(Msg msg, ValueReference errno)
{
// Drop the message if required. If we are at the end of the message
// switch back to non-dropping mode.
if (dropping) {
more = msg.hasMore();
dropping = more;
// msg_.close();
return true;
}
while (active > 0) {
if (pipes.get(current).write(msg)) {
break;
}
assert (!more);
active--;
if (current < active) {
Utils.swap(pipes, current, active);
}
else {
current = 0;
}
}
// If there are no pipes we cannot send the message.
if (active == 0) {
errno.set(ZError.EAGAIN);
return false;
}
// If it's final part of the message we can flush it downstream and
// continue round-robining (load balance).
more = msg.hasMore();
if (!more) {
pipes.get(current).flush();
if (++current >= active) {
current = 0;
}
}
return true;
}
public boolean hasOut()
{
// If one part of the message was already written we can definitely
// write the rest of the message.
if (more) {
return true;
}
while (active > 0) {
// Check whether a pipe has room for another message.
if (pipes.get(current).checkWrite()) {
return true;
}
// Deactivate the pipe.
active--;
Utils.swap(pipes, current, active);
if (current == active) {
current = 0;
}
}
return false;
}
}
jeromq-0.3.5/src/main/java/zmq/Mailbox.java 0000664 0000000 0000000 00000007362 12551504772 0020535 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 cpipe;
// Signaler to pass signals from writer thread to reader thread.
private final Signaler signaler;
// There's only one thread receiving from the mailbox, but there
// is arbitrary number of threads sending. Given that ypipe requires
// synchronised access on both of its endpoints, we have to synchronise
// the sending side.
private final Lock sync;
// True if the underlying pipe is active, ie. when we are allowed to
// read commands from it.
private boolean active;
// mailbox name, for better debugging
private final String name;
public Mailbox(String name)
{
cpipe = new YPipe(Config.COMMAND_PIPE_GRANULARITY.getValue());
sync = new ReentrantLock();
signaler = new Signaler();
// Get the pipe into passive state. That way, if the users starts by
// polling on the associated file descriptor it will get woken up when
// new command is posted.
Command cmd = cpipe.read();
assert (cmd == null);
active = false;
this.name = name;
}
public SelectableChannel getFd()
{
return signaler.getFd();
}
public void send(final Command cmd)
{
boolean ok = false;
sync.lock();
try {
cpipe.write(cmd, false);
ok = cpipe.flush();
}
finally {
sync.unlock();
}
if (!ok) {
signaler.send();
}
}
public Command recv(long timeout)
{
Command cmd = null;
// Try to get the command straight away.
if (active) {
cmd = cpipe.read();
if (cmd != null) {
return cmd;
}
// If there are no more commands available, switch into passive state.
active = false;
signaler.recv();
}
// Wait for signal from the command sender.
boolean rc = signaler.waitEvent(timeout);
if (!rc) {
return null;
}
// We've got the signal. Now we can switch into active state.
active = true;
// Get a command.
cmd = cpipe.read();
assert (cmd != null);
return cmd;
}
@Override
public void close() throws IOException
{
// TODO: Retrieve and deallocate commands inside the cpipe.
// Work around problem that other threads might still be in our
// send() method, by waiting on the mutex before disappearing.
sync.lock();
sync.unlock();
signaler.close();
}
@Override
public String toString()
{
return super.toString() + "[" + name + "]";
}
}
jeromq-0.3.5/src/main/java/zmq/Msg.java 0000664 0000000 0000000 00000012371 12551504772 0017664 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pipes;
private int min;
private int count;
private int liveNodes;
private Mtrie[] next;
public interface IMtrieHandler
{
void invoke(Pipe pipe, byte[] data, int size, Object arg);
}
public Mtrie()
{
min = 0;
count = 0;
liveNodes = 0;
pipes = null;
next = null;
}
public boolean add(byte[] prefix, Pipe pipe)
{
return addHelper(prefix, 0, pipe);
}
// Add key to the trie. Returns true if it's a new subscription
// rather than a duplicate.
public boolean add(byte[] prefix, int start, Pipe pipe)
{
return addHelper(prefix, start, pipe);
}
private boolean addHelper(byte[] prefix, int start, Pipe pipe)
{
// We are at the node corresponding to the prefix. We are done.
if (prefix == null || prefix.length == start) {
boolean result = pipes == null;
if (pipes == null) {
pipes = new HashSet();
}
pipes.add(pipe);
return result;
}
byte c = prefix[start];
if (c < min || c >= min + count) {
// The character is out of range of currently handled
// characters. We have to extend the table.
if (count == 0) {
min = c;
count = 1;
next = null;
}
else if (count == 1) {
int oldc = min;
Mtrie oldp = next[0];
count = (min < c ? c - min : min - c) + 1;
next = new Mtrie[count];
min = Math.min(min, c);
next[oldc - min] = oldp;
}
else if (min < c) {
// The new character is above the current character range.
count = c - min + 1;
next = realloc(next, count, true);
}
else {
// The new character is below the current character range.
count = (min + count) - c;
next = realloc(next, count, false);
min = c;
}
}
// If next node does not exist, create one.
if (count == 1) {
if (next == null) {
next = new Mtrie[1];
next[0] = new Mtrie();
++liveNodes;
//alloc_assert (next.node);
}
return next[0].addHelper(prefix, start + 1, pipe);
}
else {
if (next[c - min] == null) {
next[c - min] = new Mtrie();
++liveNodes;
//alloc_assert (next.table [c - min]);
}
return next[c - min].addHelper(prefix, start + 1, pipe);
}
}
private Mtrie[] realloc(Mtrie[] table, int size, boolean ended)
{
return Utils.realloc(Mtrie.class, table, size, ended);
}
// Remove all subscriptions for a specific peer from the trie.
// If there are no subscriptions left on some topics, invoke the
// supplied callback function.
public boolean rm(Pipe pipe, IMtrieHandler func, Object arg)
{
return rmHelper(pipe, new byte[0], 0, 0, func, arg);
}
private boolean rmHelper(Pipe pipe, byte[] buff, int buffsize, int maxBuffSize,
IMtrieHandler func, Object arg)
{
// Remove the subscription from this node.
if (pipes != null && pipes.remove(pipe) && pipes.isEmpty()) {
func.invoke(null, buff, buffsize, arg);
pipes = null;
}
// Adjust the buffer.
if (buffsize >= maxBuffSize) {
maxBuffSize = buffsize + 256;
buff = Utils.realloc(buff, maxBuffSize);
}
// If there are no subnodes in the trie, return.
if (count == 0) {
return true;
}
// If there's one subnode (optimisation).
if (count == 1) {
buff[buffsize] = (byte) min;
buffsize++;
next[0].rmHelper(pipe, buff, buffsize, maxBuffSize,
func, arg);
// Prune the node if it was made redundant by the removal
if (next[0].isRedundant()) {
next = null;
count = 0;
--liveNodes;
assert (liveNodes == 0);
}
return true;
}
// If there are multiple subnodes.
//
// New min non-null character in the node table after the removal
int newMin = min + count - 1;
// New max non-null character in the node table after the removal
int newMax = min;
for (int c = 0; c != count; c++) {
buff[buffsize] = (byte) (min + c);
if (next[c] != null) {
next[c].rmHelper(pipe, buff, buffsize + 1,
maxBuffSize, func, arg);
// Prune redundant nodes from the mtrie
if (next[c].isRedundant()) {
next[c] = null;
assert (liveNodes > 0);
--liveNodes;
}
else {
// The node is not redundant, so it's a candidate for being
// the new min/max node.
//
// We loop through the node array from left to right, so the
// first non-null, non-redundant node encountered is the new
// minimum index. Conversely, the last non-redundant, non-null
// node encountered is the new maximum index.
if (c + min < newMin) {
newMin = c + min;
}
if (c + min > newMax) {
newMax = c + min;
}
}
}
}
assert (count > 1);
// Free the node table if it's no longer used.
if (liveNodes == 0) {
next = null;
count = 0;
}
// Compact the node table if possible
else if (liveNodes == 1) {
// If there's only one live node in the table we can
// switch to using the more compact single-node
// representation
assert (newMin == newMax);
assert (newMin >= min && newMin < min + count);
Mtrie node = next [newMin - min];
assert (node != null);
next = null;
next = new Mtrie[]{node};
count = 1;
min = newMin;
}
else if (newMin > min || newMax < min + count - 1) {
assert (newMax - newMin + 1 > 1);
Mtrie[] oldTable = next;
assert (newMin > min || newMax < min + count - 1);
assert (newMin >= min);
assert (newMax <= min + count - 1);
assert (newMax - newMin + 1 < count);
count = newMax - newMin + 1;
next = new Mtrie[count];
System.arraycopy(oldTable, (newMin - min), next, 0, count);
min = newMin;
}
return true;
}
// Remove specific subscription from the trie. Return true is it was
// actually removed rather than de-duplicated.
public boolean rm(byte[] prefix, int start, Pipe pipe)
{
return rmHelper(prefix, start, pipe);
}
private boolean rmHelper(byte[] prefix, int start, Pipe pipe)
{
if (prefix == null || prefix.length == start) {
if (pipes != null) {
boolean erased = pipes.remove(pipe);
assert (erased);
if (pipes.isEmpty()) {
pipes = null;
}
}
return pipes == null;
}
byte c = prefix[start];
if (count == 0 || c < min || c >= min + count) {
return false;
}
Mtrie nextNode =
count == 1 ? next[0] : next[c - min];
if (nextNode == null) {
return false;
}
boolean ret = nextNode.rmHelper(prefix, start + 1, pipe);
if (nextNode.isRedundant()) {
assert (count > 0);
if (count == 1) {
next = null;
count = 0;
--liveNodes;
assert (liveNodes == 0);
}
else {
next[c - min] = null;
assert (liveNodes > 1);
--liveNodes;
// Compact the table if possible
if (liveNodes == 1) {
// If there's only one live node in the table we can
// switch to using the more compact single-node
// representation
int i;
for (i = 0; i < count; ++i) {
if (next[i] != null) {
break;
}
}
assert (i < count);
min += i;
count = 1;
Mtrie old = next [i];
next = new Mtrie [] { old };
}
else if (c == min) {
// We can compact the table "from the left"
int i;
for (i = 1; i < count; ++i) {
if (next[i] != null) {
break;
}
}
assert (i < count);
min += i;
count -= i;
next = realloc(next, count, true);
}
else if (c == min + count - 1) {
// We can compact the table "from the right"
int i;
for (i = 1; i < count; ++i) {
if (next[count - 1 - i] != null) {
break;
}
}
assert (i < count);
count -= i;
next = realloc(next, count, false);
}
}
}
return ret;
}
// Signal all the matching pipes.
public void match(byte[] data, int size, IMtrieHandler func, Object arg)
{
Mtrie current = this;
int idx = 0;
while (true) {
// Signal the pipes attached to this node.
if (current.pipes != null) {
for (Pipe it : current.pipes) {
func.invoke(it, null, 0, arg);
}
}
// If we are at the end of the message, there's nothing more to match.
if (size == 0) {
break;
}
// If there are no subnodes in the trie, return.
if (current.count == 0) {
break;
}
byte c = data[idx];
// If there's one subnode (optimisation).
if (current.count == 1) {
if (c != current.min) {
break;
}
current = current.next[0];
idx++;
size--;
continue;
}
// If there are multiple subnodes.
if (c < current.min || c >=
current.min + current.count) {
break;
}
if (current.next[c - current.min] == null) {
break;
}
current = current.next[c - current.min];
idx++;
size--;
}
}
private boolean isRedundant()
{
return pipes == null && liveNodes == 0;
}
}
jeromq-0.3.5/src/main/java/zmq/MultiMap.java 0000664 0000000 0000000 00000015106 12551504772 0020665 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 , V> implements Map
{
private long id;
private final HashMap values;
private final TreeMap> keys;
public MultiMap()
{
id = 0;
values = new HashMap();
keys = new TreeMap>();
}
public class MultiMapEntry implements Map.Entry
{
private K key;
private V value;
public MultiMapEntry(K key, V value)
{
this.key = key;
this.value = value;
}
@Override
public K getKey()
{
return key;
}
@Override
public V getValue()
{
return value;
}
@Override
public V setValue(V value)
{
V old = this.value;
this.value = value;
return old;
}
}
public class MultiMapEntrySet implements Set>, Iterator>
{
private MultiMap map;
private Iterator>> it;
private Iterator iit;
private K key;
private long id;
public MultiMapEntrySet(MultiMap map)
{
this.map = map;
}
@Override
public boolean add(Map.Entry arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection> arg0)
{
throw new UnsupportedOperationException();
}
@Override
public void clear()
{
throw new UnsupportedOperationException();
}
@Override
public boolean contains(Object arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean isEmpty()
{
throw new UnsupportedOperationException();
}
@Override
public Iterator> iterator()
{
it = map.keys.entrySet().iterator();
return this;
}
@Override
public boolean remove(Object arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection arg0)
{
throw new UnsupportedOperationException();
}
@Override
public int size()
{
throw new UnsupportedOperationException();
}
@Override
public Object[] toArray()
{
throw new UnsupportedOperationException();
}
@Override
public T[] toArray(T[] arg0)
{
throw new UnsupportedOperationException();
}
@Override
public boolean hasNext()
{
if (iit == null || !iit.hasNext()) {
if (!it.hasNext()) {
return false;
}
Map.Entry> item = it.next();
key = item.getKey();
iit = item.getValue().iterator();
}
return true;
}
@Override
public Map.Entry next()
{
id = iit.next();
return new MultiMapEntry(key, map.values.get(id));
}
@Override
public void remove()
{
iit.remove();
map.values.remove(id);
if (map.keys.get(key).isEmpty()) {
it.remove();
}
}
}
@Override
public void clear()
{
keys.clear();
values.clear();
}
@Override
public boolean containsKey(Object key)
{
return keys.containsKey(key);
}
@Override
public boolean containsValue(Object value)
{
return values.containsValue(value);
}
@Override
public Set> entrySet()
{
return new MultiMapEntrySet(this);
}
@Override
public V get(Object key)
{
ArrayList l = keys.get(key);
if (l == null) {
return null;
}
return values.get(l.get(0));
}
@Override
public boolean isEmpty()
{
return keys.isEmpty();
}
@Override
public Set keySet()
{
return keys.keySet();
}
@Override
public V put(K key, V value)
{
ArrayList ids = keys.get(key);
if (ids == null) {
ids = new ArrayList();
ids.add(id);
keys.put(key, ids);
}
else {
ids.add(id);
}
values.put(id, value);
id++;
return null;
}
@Override
public void putAll(Map src)
{
for (Entry o : src.entrySet()) {
put(o.getKey(), o.getValue());
}
}
@Override
public V remove(Object key)
{
ArrayList l = keys.get(key);
if (l == null) {
return null;
}
V old = values.remove(l.remove(0));
if (l.isEmpty()) {
keys.remove(key);
}
return old;
}
@Override
public int size()
{
return values.size();
}
@Override
public Collection values()
{
return values.values();
}
}
jeromq-0.3.5/src/main/java/zmq/Options.java 0000664 0000000 0000000 00000026746 12551504772 0020604 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 tcp_accept_filters_t;
final List tcpAcceptFilters;
// ID of the socket.
int socketId;
Class decoder;
Class encoder;
public Options()
{
sendHwm = 1000;
recvHwm = 1000;
affinity = 0;
identitySize = 0;
rate = 100;
recoveryIvl = 10000;
multicastHops = 1;
sndbuf = 0;
rcvbuf = 0;
type = -1;
linger = -1;
reconnectIvl = 100;
reconnectIvlMax = 0;
backlog = 100;
maxMsgSize = -1;
recvTimeout = -1;
sendTimeout = -1;
ipv4only = 1;
delayAttachOnConnect = 0;
delayOnClose = true;
delayOnDisconnect = true;
filter = false;
recvIdentity = false;
tcpKeepAlive = -1;
tcpKeepAliveCnt = -1;
tcpKeepAliveIdle = -1;
tcpKeepAliveIntvl = -1;
socketId = 0;
identity = null;
tcpAcceptFilters = new ArrayList();
decoder = null;
encoder = null;
}
@SuppressWarnings("unchecked")
public void setSocketOpt(int option, Object optval)
{
switch (option) {
case ZMQ.ZMQ_SNDHWM:
sendHwm = (Integer) optval;
if (sendHwm < 0) {
throw new IllegalArgumentException("sendHwm " + optval);
}
return;
case ZMQ.ZMQ_RCVHWM:
recvHwm = (Integer) optval;
if (recvHwm < 0) {
throw new IllegalArgumentException("recvHwm " + optval);
}
return;
case ZMQ.ZMQ_AFFINITY:
affinity = (Long) optval;
return;
case ZMQ.ZMQ_IDENTITY:
byte[] val;
if (optval instanceof String) {
val = ((String) optval).getBytes(ZMQ.CHARSET);
}
else if (optval instanceof byte[]) {
val = (byte[]) optval;
}
else {
throw new IllegalArgumentException("identity " + optval);
}
if (val == null || val.length > 255) {
throw new IllegalArgumentException("identity must not be null or less than 255 " + optval);
}
identity = Arrays.copyOf(val, val.length);
identitySize = (byte) identity.length;
return;
case ZMQ.ZMQ_RATE:
rate = (Integer) optval;
return;
case ZMQ.ZMQ_RECOVERY_IVL:
recoveryIvl = (Integer) optval;
return;
case ZMQ.ZMQ_SNDBUF:
sndbuf = (Integer) optval;
return;
case ZMQ.ZMQ_RCVBUF:
rcvbuf = (Integer) optval;
return;
case ZMQ.ZMQ_LINGER:
linger = (Integer) optval;
return;
case ZMQ.ZMQ_RECONNECT_IVL:
reconnectIvl = (Integer) optval;
if (reconnectIvl < -1) {
throw new IllegalArgumentException("reconnectIvl " + optval);
}
return;
case ZMQ.ZMQ_RECONNECT_IVL_MAX:
reconnectIvlMax = (Integer) optval;
if (reconnectIvlMax < 0) {
throw new IllegalArgumentException("reconnectIvlMax " + optval);
}
return;
case ZMQ.ZMQ_BACKLOG:
backlog = (Integer) optval;
return;
case ZMQ.ZMQ_MAXMSGSIZE:
maxMsgSize = (Long) optval;
return;
case ZMQ.ZMQ_MULTICAST_HOPS:
multicastHops = (Integer) optval;
return;
case ZMQ.ZMQ_RCVTIMEO:
recvTimeout = (Integer) optval;
return;
case ZMQ.ZMQ_SNDTIMEO:
sendTimeout = (Integer) optval;
return;
case ZMQ.ZMQ_IPV4ONLY:
ipv4only = (Integer) optval;
if (ipv4only != 0 && ipv4only != 1) {
throw new IllegalArgumentException("ipv4only only accepts 0 or 1 " + optval);
}
return;
case ZMQ.ZMQ_TCP_KEEPALIVE:
tcpKeepAlive = (Integer) optval;
if (tcpKeepAlive != -1 && tcpKeepAlive != 0 && tcpKeepAlive != 1) {
throw new IllegalArgumentException("tcpKeepAlive only accepts one of -1,0,1 " + optval);
}
return;
case ZMQ.ZMQ_DELAY_ATTACH_ON_CONNECT:
delayAttachOnConnect = (Integer) optval;
if (delayAttachOnConnect != 0 && delayAttachOnConnect != 1) {
throw new IllegalArgumentException("delayAttachOnConnect only accept 0 or 1 " + optval);
}
return;
case ZMQ.ZMQ_TCP_KEEPALIVE_CNT:
case ZMQ.ZMQ_TCP_KEEPALIVE_IDLE:
case ZMQ.ZMQ_TCP_KEEPALIVE_INTVL:
// not supported
return;
case ZMQ.ZMQ_TCP_ACCEPT_FILTER:
String filterStr = (String) optval;
if (filterStr == null) {
tcpAcceptFilters.clear();
}
else if (filterStr.length() == 0 || filterStr.length() > 255) {
throw new IllegalArgumentException("tcp_accept_filter " + optval);
}
else {
TcpAddressMask filter = new TcpAddressMask();
filter.resolve(filterStr, ipv4only == 1);
tcpAcceptFilters.add(filter);
}
return;
case ZMQ.ZMQ_ENCODER:
if (optval instanceof String) {
try {
encoder = Class.forName((String) optval).asSubclass(EncoderBase.class);
}
catch (ClassNotFoundException e) {
throw new IllegalArgumentException(e);
}
}
else if (optval instanceof Class) {
encoder = (Class) optval;
}
else {
throw new IllegalArgumentException("encoder " + optval);
}
return;
case ZMQ.ZMQ_DECODER:
if (optval instanceof String) {
try {
decoder = Class.forName((String) optval).asSubclass(DecoderBase.class);
}
catch (ClassNotFoundException e) {
throw new IllegalArgumentException(e);
}
}
else if (optval instanceof Class) {
decoder = (Class) optval;
}
else {
throw new IllegalArgumentException("decoder " + optval);
}
return;
default:
throw new IllegalArgumentException("Unknown Option " + option);
}
}
public Object getsockopt(int option)
{
switch (option) {
case ZMQ.ZMQ_SNDHWM:
return sendHwm;
case ZMQ.ZMQ_RCVHWM:
return recvHwm;
case ZMQ.ZMQ_AFFINITY:
return affinity;
case ZMQ.ZMQ_IDENTITY:
return identity;
case ZMQ.ZMQ_RATE:
return rate;
case ZMQ.ZMQ_RECOVERY_IVL:
return recoveryIvl;
case ZMQ.ZMQ_SNDBUF:
return sndbuf;
case ZMQ.ZMQ_RCVBUF:
return rcvbuf;
case ZMQ.ZMQ_TYPE:
return type;
case ZMQ.ZMQ_LINGER:
return linger;
case ZMQ.ZMQ_RECONNECT_IVL:
return reconnectIvl;
case ZMQ.ZMQ_RECONNECT_IVL_MAX:
return reconnectIvlMax;
case ZMQ.ZMQ_BACKLOG:
return backlog;
case ZMQ.ZMQ_MAXMSGSIZE:
return maxMsgSize;
case ZMQ.ZMQ_MULTICAST_HOPS:
return multicastHops;
case ZMQ.ZMQ_RCVTIMEO:
return recvTimeout;
case ZMQ.ZMQ_SNDTIMEO:
return sendTimeout;
case ZMQ.ZMQ_IPV4ONLY:
return ipv4only;
case ZMQ.ZMQ_TCP_KEEPALIVE:
return tcpKeepAlive;
case ZMQ.ZMQ_DELAY_ATTACH_ON_CONNECT:
return delayAttachOnConnect;
case ZMQ.ZMQ_TCP_KEEPALIVE_CNT:
case ZMQ.ZMQ_TCP_KEEPALIVE_IDLE:
case ZMQ.ZMQ_TCP_KEEPALIVE_INTVL:
// not supported
return 0;
case ZMQ.ZMQ_LAST_ENDPOINT:
return lastEndpoint;
default:
throw new IllegalArgumentException("option=" + option);
}
}
}
jeromq-0.3.5/src/main/java/zmq/Own.java 0000664 0000000 0000000 00000017726 12551504772 0017712 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 owned_t;
private final Set owned;
// Number of events we have to get before we can destroy the object.
private int termAcks;
// Note that the owner is unspecified in the constructor.
// It'll be supplied later on when the object is plugged in.
// The object is not living within an I/O thread. It has it's own
// thread outside of 0MQ infrastructure.
public Own(Ctx parent, int tid)
{
super(parent, tid);
terminating = false;
sendSeqnum = new AtomicLong(0);
processedSeqnum = 0;
owner = null;
termAcks = 0;
options = new Options();
owned = new HashSet();
}
// The object is living within I/O thread.
public Own(IOThread ioThread, Options options)
{
super(ioThread);
this.options = options;
terminating = false;
sendSeqnum = new AtomicLong(0);
processedSeqnum = 0;
owner = null;
termAcks = 0;
owned = new HashSet();
}
public abstract void destroy();
// A place to hook in when phyicallal destruction of the object
// is to be delayed.
protected void processDestroy()
{
destroy();
}
private void setOwner(Own owner)
{
assert (this.owner == null);
this.owner = owner;
}
// When another owned object wants to send command to this object
// it calls this function to let it know it should not shut down
// before the command is delivered.
void incSeqnum()
{
// This function may be called from a different thread!
sendSeqnum.incrementAndGet();
}
protected void processSeqnum()
{
// Catch up with counter of processed commands.
processedSeqnum++;
// We may have catched up and still have pending terms acks.
checkTermAcks();
}
// Launch the supplied object and become its owner.
protected void launchChild(Own object)
{
// Specify the owner of the object.
object.setOwner(this);
// Plug the object into the I/O thread.
sendPlug(object);
// Take ownership of the object.
sendOwn(this, object);
}
// Terminate owned object
protected void termChild(Own object)
{
processTermReq(object);
}
@Override
protected void processTermReq(Own object)
{
// When shutting down we can ignore termination requests from owned
// objects. The termination request was already sent to the object.
if (terminating) {
return;
}
// If I/O object is well and alive let's ask it to terminate.
// If not found, we assume that termination request was already sent to
// the object so we can safely ignore the request.
if (!owned.contains(object)) {
return;
}
owned.remove(object);
registerTermAcks(1);
// Note that this object is the root of the (partial shutdown) thus, its
// value of linger is used, rather than the value stored by the children.
sendTerm(object, options.linger);
}
protected void processOwn(Own object)
{
// If the object is already being shut down, new owned objects are
// immediately asked to terminate. Note that linger is set to zero.
if (terminating) {
registerTermAcks(1);
sendTerm(object, 0);
return;
}
// Store the reference to the owned object.
owned.add(object);
}
// Ask owner object to terminate this object. It may take a while
// while actual termination is started. This function should not be
// called more than once.
protected void terminate()
{
// If termination is already underway, there's no point
// in starting it anew.
if (terminating) {
return;
}
// As for the root of the ownership tree, there's noone to terminate it,
// so it has to terminate itself.
if (owner == null) {
processTerm(options.linger);
return;
}
// If I am an owned object, I'll ask my owner to terminate me.
sendTermReq(owner, this);
}
// Returns true if the object is in process of termination.
protected boolean isTerminating()
{
return terminating;
}
// Term handler is protocted rather than private so that it can
// be intercepted by the derived class. This is useful to add custom
// steps to the beginning of the termination process.
@Override
protected void processTerm(int linger)
{
// Double termination should never happen.
assert (!terminating);
// Send termination request to all owned objects.
for (Own it : owned) {
sendTerm(it, linger);
}
registerTermAcks(owned.size());
owned.clear();
// Start termination process and check whether by chance we cannot
// terminate immediately.
terminating = true;
checkTermAcks();
}
// Use following two functions to wait for arbitrary events before
// terminating. Just add number of events to wait for using
// register_tem_acks functions. When event occurs, call
// remove_term_ack. When number of pending acks reaches zero
// object will be deallocated.
public void registerTermAcks(int count)
{
termAcks += count;
}
public void unregisterTermAck()
{
assert (termAcks > 0);
termAcks--;
// This may be a last ack we are waiting for before termination...
checkTermAcks();
}
@Override
protected void processTermAck()
{
unregisterTermAck();
}
private void checkTermAcks()
{
if (terminating && processedSeqnum == sendSeqnum.get() &&
termAcks == 0) {
// Sanity check. There should be no active children at this point.
assert (owned.isEmpty());
// The root object has nobody to confirm the termination to.
// Other nodes will confirm the termination to the owner.
if (owner != null) {
sendTermAck(owner);
}
// Deallocate the resources.
processDestroy();
}
}
}
jeromq-0.3.5/src/main/java/zmq/Pair.java 0000664 0000000 0000000 00000005735 12551504772 0020037 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 inpipe;
private YPipe outpipe;
// Can the pipe be read from / written to?
private boolean inActive;
private boolean outActive;
// High watermark for the outbound pipe.
private int hwm;
// Low watermark for the inbound pipe.
private int lwm;
// Number of messages read and written so far.
private long msgsRead;
private long msgsWritten;
// Last received peer's msgsRead. The actual number in the peer
// can be higher at the moment.
private long peersMsgsRead;
// The pipe object on the other side of the pipepair.
private Pipe peer;
// Sink to send events to.
private IPipeEvents sink;
// State of the pipe endpoint. Active is common state before any
// termination begins. Delimited means that delimiter was read from
// pipe before term command was received. Pending means that term
// command was already received from the peer but there are still
// pending messages to read. Terminating means that all pending
// messages were already read and all we are waiting for is ack from
// the peer. Terminated means that 'terminate' was explicitly called
// by the user. Double_terminated means that user called 'terminate'
// and then we've got term command from the peer as well.
enum State {
ACTIVE,
DELIMITED,
PENDING,
TERMINATING,
TERMINATED,
DOUBLE_TERMINATED
}
private State state;
// If true, we receive all the pending inbound messages before
// terminating. If false, we terminate immediately when the peer
// asks us to.
private boolean delay;
// Identity of the writer. Used uniquely by the reader side.
private Blob identity;
// JeroMQ only
private ZObject parent;
// Constructor is private. Pipe can only be created using
// pipepair function.
private Pipe(ZObject parent, YPipe inpipe, YPipe outpipe,
int inhwm, int outhwm, boolean delay)
{
super(parent);
this.inpipe = inpipe;
this.outpipe = outpipe;
inActive = true;
outActive = true;
hwm = outhwm;
lwm = computeLwm(inhwm);
msgsRead = 0;
msgsWritten = 0;
peersMsgsRead = 0;
peer = null;
sink = null;
state = State.ACTIVE;
this.delay = delay;
this.parent = parent;
}
// Create a pipepair for bi-directional transfer of messages.
// First HWM is for messages passed from first pipe to the second pipe.
// Second HWM is for messages passed from second pipe to the first pipe.
// Delay specifies how the pipe behaves when the peer terminates. If true
// pipe receives all the pending messages before terminating, otherwise it
// terminates straight away.
public static void pipepair(ZObject[] parents, Pipe[] pipes, int[] hwms,
boolean[] delays)
{
// Creates two pipe objects. These objects are connected by two ypipes,
// each to pass messages in one direction.
YPipe upipe1 = new YPipe(Config.MESSAGE_PIPE_GRANULARITY.getValue());
YPipe upipe2 = new YPipe(Config.MESSAGE_PIPE_GRANULARITY.getValue());
pipes[0] = new Pipe(parents[0], upipe1, upipe2,
hwms[1], hwms[0], delays[0]);
pipes[1] = new Pipe(parents[1], upipe2, upipe1,
hwms[0], hwms[1], delays[1]);
pipes[0].setPeer(pipes[1]);
pipes[1].setPeer(pipes[0]);
}
// Pipepair uses this function to let us know about
// the peer pipe object.
private void setPeer(Pipe peer)
{
// Peer can be set once only.
assert (peer != null);
this.peer = peer;
}
// Specifies the object to send events to.
public void setEventSink(IPipeEvents sink)
{
assert (this.sink == null);
this.sink = sink;
}
// Pipe endpoint can store an opaque ID to be used by its clients.
public void setIdentity(Blob identity)
{
this.identity = identity;
}
public Blob getIdentity()
{
return identity;
}
// Returns true if there is at least one message to read in the pipe.
public boolean checkRead()
{
if (!inActive || (state != State.ACTIVE && state != State.PENDING)) {
return false;
}
// Check if there's an item in the pipe.
if (!inpipe.checkRead()) {
inActive = false;
return false;
}
// If the next item in the pipe is message delimiter,
// initiate termination process.
if (isDelimiter(inpipe.probe())) {
Msg msg = inpipe.read();
assert (msg != null);
delimit();
return false;
}
return true;
}
// Reads a message to the underlying pipe.
public Msg read()
{
if (!inActive || (state != State.ACTIVE && state != State.PENDING)) {
return null;
}
Msg msg = inpipe.read();
if (msg == null) {
inActive = false;
return null;
}
// If delimiter was read, start termination process of the pipe.
if (msg.isDelimiter()) {
delimit();
return null;
}
if (!msg.hasMore()) {
msgsRead++;
}
if (lwm > 0 && msgsRead % lwm == 0) {
sendActivateWrite(peer, msgsRead);
}
return msg;
}
// Checks whether messages can be written to the pipe. If writing
// the message would cause high watermark the function returns false.
public boolean checkWrite()
{
if (!outActive || state != State.ACTIVE) {
return false;
}
boolean full = hwm > 0 && msgsWritten - peersMsgsRead == (long) (hwm);
if (full) {
outActive = false;
return false;
}
return true;
}
// Writes a message to the underlying pipe. Returns false if the
// message cannot be written because high watermark was reached.
public boolean write(Msg msg)
{
if (!checkWrite()) {
return false;
}
boolean more = msg.hasMore();
outpipe.write(msg, more);
if (!more) {
msgsWritten++;
}
return true;
}
// Remove unfinished parts of the outbound message from the pipe.
public void rollback()
{
// Remove incomplete message from the outbound pipe.
Msg msg;
if (outpipe != null) {
while ((msg = outpipe.unwrite()) != null) {
assert ((msg.flags() & Msg.MORE) > 0);
}
}
}
// Flush the messages downsteam.
public void flush()
{
// The peer does not exist anymore at this point.
if (state == State.TERMINATING) {
return;
}
if (outpipe != null && !outpipe.flush()) {
sendActivateRead(peer);
}
}
@Override
protected void processActivateRead()
{
if (!inActive && (state == State.ACTIVE || state == State.PENDING)) {
inActive = true;
sink.readActivated(this);
}
}
@Override
protected void processActivateWrite(long msgsRead)
{
// Remember the peers's message sequence number.
peersMsgsRead = msgsRead;
if (!outActive && state == State.ACTIVE) {
outActive = true;
sink.writeActivated(this);
}
}
@SuppressWarnings("unchecked")
@Override
protected void processHiccup(Object pipe)
{
// Destroy old outpipe. Note that the read end of the pipe was already
// migrated to this thread.
assert (outpipe != null);
outpipe.flush();
while (outpipe.read() != null) {
// do nothing
}
// Plug in the new outpipe.
assert (pipe != null);
outpipe = (YPipe) pipe;
outActive = true;
// If appropriate, notify the user about the hiccup.
if (state == State.ACTIVE) {
sink.hiccuped(this);
}
}
@Override
protected void processPipeTerm()
{
// This is the simple case of peer-induced termination. If there are no
// more pending messages to read, or if the pipe was configured to drop
// pending messages, we can move directly to the terminating state.
// Otherwise we'll hang up in pending state till all the pending messages
// are sent.
if (state == State.ACTIVE) {
if (!delay) {
state = State.TERMINATING;
outpipe = null;
sendPipeTermAck(peer);
}
else {
state = State.PENDING;
}
return;
}
// Delimiter happened to arrive before the term command. Now we have the
// term command as well, so we can move straight to terminating state.
if (state == State.DELIMITED) {
state = State.TERMINATING;
outpipe = null;
sendPipeTermAck(peer);
return;
}
// This is the case where both ends of the pipe are closed in parallel.
// We simply reply to the request by ack and continue waiting for our
// own ack.
if (state == State.TERMINATED) {
state = State.DOUBLE_TERMINATED;
outpipe = null;
sendPipeTermAck(peer);
return;
}
// pipe_term is invalid in other states.
assert (false);
}
@Override
protected void processPipeTermAck()
{
// Notify the user that all the references to the pipe should be dropped.
assert (sink != null);
sink.pipeTerminated(this);
// In terminating and double_terminated states there's nothing to do.
// Simply deallocate the pipe. In terminated state we have to ack the
// peer before deallocating this side of the pipe. All the other states
// are invalid.
if (state == State.TERMINATED) {
outpipe = null;
sendPipeTermAck(peer);
}
else {
assert (state == State.TERMINATING || state == State.DOUBLE_TERMINATED);
}
// We'll deallocate the inbound pipe, the peer will deallocate the outbound
// pipe (which is an inbound pipe from its point of view).
// First, delete all the unread messages in the pipe. We have to do it by
// hand because msg_t doesn't have automatic destructor. Then deallocate
// the ypipe itself.
while (inpipe.read() != null) {
// do nothing
}
inpipe = null;
// Deallocate the pipe object
}
// Ask pipe to terminate. The termination will happen asynchronously
// and user will be notified about actual deallocation by 'terminated'
// event. If delay is true, the pending messages will be processed
// before actual shutdown.
public void terminate(boolean delay)
{
// Overload the value specified at pipe creation.
this.delay = delay;
// If terminate was already called, we can ignore the duplicit invocation.
if (state == State.TERMINATED || state == State.DOUBLE_TERMINATED) {
return;
}
// If the pipe is in the final phase of async termination, it's going to
// closed anyway. No need to do anything special here.
else if (state == State.TERMINATING) {
return;
}
// The simple sync termination case. Ask the peer to terminate and wait
// for the ack.
else if (state == State.ACTIVE) {
sendPipeTerm(peer);
state = State.TERMINATED;
}
// There are still pending messages available, but the user calls
// 'terminate'. We can act as if all the pending messages were read.
else if (state == State.PENDING && !this.delay) {
outpipe = null;
sendPipeTermAck(peer);
state = State.TERMINATING;
}
// If there are pending messages still available, do nothing.
else if (state == State.PENDING) {
// do nothing
}
// We've already got delimiter, but not term command yet. We can ignore
// the delimiter and ack synchronously terminate as if we were in
// active state.
else if (state == State.DELIMITED) {
sendPipeTerm(peer);
state = State.TERMINATED;
}
// There are no other states.
else {
assert (false);
}
// Stop outbound flow of messages.
outActive = false;
if (outpipe != null) {
// Drop any unfinished outbound messages.
rollback();
// Write the delimiter into the pipe. Note that watermarks are not
// checked; thus the delimiter can be written even when the pipe is full.
Msg msg = new Msg();
msg.initDelimiter();
outpipe.write(msg, false);
flush();
}
}
// Returns true if the message is delimiter; false otherwise.
private static boolean isDelimiter(Msg msg)
{
return msg.isDelimiter();
}
// Computes appropriate low watermark from the given high watermark.
private static int computeLwm(int hwm)
{
// Compute the low water mark. Following point should be taken
// into consideration:
//
// 1. LWM has to be less than HWM.
// 2. LWM cannot be set to very low value (such as zero) as after filling
// the queue it would start to refill only after all the messages are
// read from it and thus unnecessarily hold the progress back.
// 3. LWM cannot be set to very high value (such as HWM-1) as it would
// result in lock-step filling of the queue - if a single message is
// read from a full queue, writer thread is resumed to write exactly one
// message to the queue and go back to sleep immediately. This would
// result in low performance.
//
// Given the 3. it would be good to keep HWM and LWM as far apart as
// possible to reduce the thread switching overhead to almost zero,
// say HWM-LWM should be max_wm_delta.
//
// That done, we still we have to account for the cases where
// HWM < max_wm_delta thus driving LWM to negative numbers.
// Let's make LWM 1/2 of HWM in such cases.
return (hwm > Config.MAX_WM_DELTA.getValue() * 2) ?
hwm - Config.MAX_WM_DELTA.getValue() : (hwm + 1) / 2;
}
// Handler for delimiter read from the pipe.
private void delimit()
{
if (state == State.ACTIVE) {
state = State.DELIMITED;
return;
}
if (state == State.PENDING) {
outpipe = null;
sendPipeTermAck(peer);
state = State.TERMINATING;
return;
}
// Delimiter in any other state is invalid.
assert (false);
}
// Temporaraily disconnects the inbound message stream and drops
// all the messages on the fly. Causes 'hiccuped' event to be generated
// in the peer.
public void hiccup()
{
// If termination is already under way do nothing.
if (state != State.ACTIVE) {
return;
}
// We'll drop the pointer to the inpipe. From now on, the peer is
// responsible for deallocating it.
inpipe = null;
// Create new inpipe.
inpipe = new YPipe(Config.MESSAGE_PIPE_GRANULARITY.getValue());
inActive = true;
// Notify the peer about the hiccup.
sendHiccup(peer, inpipe);
}
@Override
public String toString()
{
return super.toString() + "[" + parent + "]";
}
}
jeromq-0.3.5/src/main/java/zmq/PollItem.java 0000664 0000000 0000000 00000007336 12551504772 0020670 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 fdTable;
// If true, there's at least one retired event source.
private final AtomicBoolean retired = new AtomicBoolean(false);
// If true, thread is in the process of shutting down.
private volatile boolean stopping;
private volatile boolean stopped;
private Thread worker;
private Selector selector;
private final String name;
public Poller()
{
this("poller");
}
public Poller(String name)
{
this.name = name;
stopping = false;
stopped = false;
fdTable = new HashMap();
try {
selector = Selector.open();
}
catch (IOException e) {
throw new ZError.IOException(e);
}
}
public void destroy()
{
if (!stopped) {
try {
worker.join();
}
catch (InterruptedException e) {
}
}
try {
selector.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
public final void addHandle(SelectableChannel fd, IPollEvents events)
{
fdTable.put(fd, new PollSet(events));
adjustLoad(1);
}
public final void removeHandle(SelectableChannel handle)
{
fdTable.get(handle).cancelled = true;
retired.set(true);
// Decrease the load metric of the thread.
adjustLoad(-1);
}
public final void setPollIn(SelectableChannel handle)
{
register(handle, SelectionKey.OP_READ, false);
}
public final void resetPollOn(SelectableChannel handle)
{
register(handle, SelectionKey.OP_READ, true);
}
public final void setPollOut(SelectableChannel handle)
{
register(handle, SelectionKey.OP_WRITE, false);
}
public final void resetPollOut(SelectableChannel handle)
{
register(handle, SelectionKey.OP_WRITE, true);
}
public final void setPollConnect(SelectableChannel handle)
{
register(handle, SelectionKey.OP_CONNECT, false);
}
public final void setPollAccept(SelectableChannel handle)
{
register(handle, SelectionKey.OP_ACCEPT, false);
}
private final void register(SelectableChannel handle, int ops, boolean negate)
{
PollSet pollset = fdTable.get(handle);
if (negate) {
pollset.ops = pollset.ops & ~ops;
}
else {
pollset.ops = pollset.ops | ops;
}
if (pollset.key != null) {
pollset.key.interestOps(pollset.ops);
}
else {
retired.set(true);
}
}
public void start()
{
worker = new Thread(this, name);
worker.setDaemon(true);
worker.start();
}
public void stop()
{
stopping = true;
selector.wakeup();
}
@Override
public void run()
{
int returnsImmediately = 0;
while (!stopping) {
// Execute any due timers.
long timeout = executeTimers();
while (retired.compareAndSet(true, false)) {
Iterator> it = fdTable.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = it.next();
SelectableChannel ch = entry.getKey();
PollSet pollset = entry.getValue();
if (pollset.key == null) {
try {
pollset.key = ch.register(selector, pollset.ops, pollset.handler);
}
catch (ClosedChannelException e) {
}
}
if (pollset.cancelled || !ch.isOpen()) {
if (pollset.key != null) {
pollset.key.cancel();
}
it.remove();
}
}
}
// Wait for events.
int rc;
long start = System.currentTimeMillis();
try {
rc = selector.select(timeout);
}
catch (IOException e) {
throw new ZError.IOException(e);
}
if (rc == 0) {
// Guess JDK epoll bug
if (timeout == 0 ||
System.currentTimeMillis() - start < timeout / 2) {
returnsImmediately++;
}
else {
returnsImmediately = 0;
}
if (returnsImmediately > 10) {
rebuildSelector();
returnsImmediately = 0;
}
continue;
}
Iterator it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
IPollEvents evt = (IPollEvents) key.attachment();
it.remove();
try {
if (key.isReadable()) {
evt.inEvent();
}
else if (key.isAcceptable()) {
evt.acceptEvent();
}
else if (key.isConnectable()) {
evt.connectEvent();
}
if (key.isWritable()) {
evt.outEvent();
}
}
catch (CancelledKeyException e) {
// channel might have been closed
}
}
}
stopped = true;
}
private void rebuildSelector()
{
Selector newSelector;
try {
newSelector = Selector.open();
}
catch (IOException e) {
throw new ZError.IOException(e);
}
try {
selector.close();
}
catch (IOException e) {
}
selector = newSelector;
for (PollSet pollSet : fdTable.values()) {
pollSet.key = null;
}
retired.set(true);
}
}
jeromq-0.3.5/src/main/java/zmq/PollerBase.java 0000664 0000000 0000000 00000010417 12551504772 0021165 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 timers;
private final Map addingTimers;
protected PollerBase()
{
load = new AtomicInteger(0);
timers = new MultiMap();
addingTimers = new MultiMap();
}
// Returns load of the poller. Note that this function can be
// invoked from a different thread!
public final int getLoad()
{
return load.get();
}
// Called by individual poller implementations to manage the load.
protected void adjustLoad(int amount)
{
load.addAndGet(amount);
}
// Add a timeout to expire in timeout_ milliseconds. After the
// expiration timerEvent on sink_ object will be called with
// argument set to id_.
public void addTimer(long timeout, IPollEvents sink, int id)
{
long expiration = Clock.nowMS() + timeout;
TimerInfo info = new TimerInfo(sink, id);
addingTimers.put(expiration, info);
}
// Cancel the timer created by sink_ object with ID equal to id_.
public void cancelTimer(IPollEvents sink, int id)
{
// Complexity of this operation is O(n). We assume it is rarely used.
if (!addingTimers.isEmpty()) {
timers.putAll(addingTimers);
addingTimers.clear();
}
Iterator> it = timers.entrySet().iterator();
while (it.hasNext()) {
TimerInfo v = it.next().getValue();
if (v.sink == sink && v.id == id) {
it.remove();
return;
}
}
// Timer not found.
assert (false);
}
// Executes any timers that are due. Returns number of milliseconds
// to wait to match the next timer or 0 meaning "no timers".
protected long executeTimers()
{
if (!addingTimers.isEmpty()) {
timers.putAll(addingTimers);
addingTimers.clear();
}
// Fast track.
if (timers.isEmpty()) {
return 0L;
}
// Get the current time.
long current = Clock.nowMS();
// Execute the timers that are already due.
Iterator> it = timers.entrySet().iterator();
while (it.hasNext()) {
Entry o = it.next();
// If we have to wait to execute the item, same will be true about
// all the following items (multimap is sorted). Thus we can stop
// checking the subsequent timers and return the time to wait for
// the next timer (at least 1ms).
if (o.getKey() > current) {
return o.getKey() - current;
}
// Trigger the timer.
o.getValue().sink.timerEvent(o.getValue().id);
// Remove it from the list of active timers.
it.remove();
}
if (!addingTimers.isEmpty()) {
return executeTimers();
}
// There are no more timers.
return 0L;
}
}
jeromq-0.3.5/src/main/java/zmq/Proxy.java 0000664 0000000 0000000 00000010676 12551504772 0020265 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 anonymousPipes;
// Outbound pipes indexed by the peer IDs.
private final Map outpipes;
// The pipe we are currently writing to.
private Pipe currentOut;
// If true, more outgoing message parts are expected.
private boolean moreOut;
// Peer ID are generated. It's a simple increment and wrap-over
// algorithm. This value is the next ID to use (if not used already).
private int nextPeerId;
// If true, report EHOSTUNREACH to the caller instead of silently dropping
// the message targeting an unknown peer.
private boolean mandatory;
private boolean handover;
public Router(Ctx parent, int tid, int sid)
{
super(parent, tid, sid);
prefetched = false;
identitySent = false;
moreIn = false;
currentOut = null;
moreOut = false;
nextPeerId = Utils.generateRandom();
mandatory = false;
handover = false;
options.type = ZMQ.ZMQ_ROUTER;
fq = new FQ();
prefetchedId = new Msg();
prefetchedMsg = new Msg();
anonymousPipes = new HashSet();
outpipes = new HashMap();
// TODO: Uncomment the following line when ROUTER will become true ROUTER
// rather than generic router socket.
// If peer disconnect there's noone to send reply to anyway. We can drop
// all the outstanding requests from that peer.
// options.delayOnDisconnect = false;
options.recvIdentity = true;
}
@Override
public void xattachPipe(Pipe pipe, boolean icanhasall)
{
assert (pipe != null);
boolean identityOk = identifyPeer(pipe);
if (identityOk) {
fq.attach(pipe);
}
else {
anonymousPipes.add(pipe);
}
}
@Override
public boolean xsetsockopt(int option, Object optval)
{
if (option == ZMQ.ZMQ_ROUTER_MANDATORY) {
mandatory = (Integer) optval == 1;
return true;
}
if (option == ZMQ.ZMQ_ROUTER_HANDOVER) {
handover = (Integer) optval == 1;
return true;
}
return false;
}
@Override
public void xpipeTerminated(Pipe pipe)
{
if (!anonymousPipes.remove(pipe)) {
Outpipe old = outpipes.remove(pipe.getIdentity());
assert (old != null);
fq.terminated(pipe);
if (pipe == currentOut) {
currentOut = null;
}
}
}
@Override
public void xreadActivated(Pipe pipe)
{
if (!anonymousPipes.contains(pipe)) {
fq.activated(pipe);
}
else {
boolean identityOk = identifyPeer(pipe);
if (identityOk) {
anonymousPipes.remove(pipe);
fq.attach(pipe);
}
}
}
@Override
public void xwriteActivated(Pipe pipe)
{
for (Map.Entry it : outpipes.entrySet()) {
if (it.getValue().pipe == pipe) {
assert (!it.getValue().active);
it.getValue().active = true;
return;
}
}
assert (false);
}
@Override
protected boolean xsend(Msg msg)
{
// If this is the first part of the message it's the ID of the
// peer to send the message to.
if (!moreOut) {
assert (currentOut == null);
// If we have malformed message (prefix with no subsequent message)
// then just silently ignore it.
// TODO: The connections should be killed instead.
if (msg.hasMore()) {
moreOut = true;
// Find the pipe associated with the identity stored in the prefix.
// If there's no such pipe just silently ignore the message, unless
// mandatory is set.
Blob identity = Blob.createBlob(msg.data(), true);
Outpipe op = outpipes.get(identity);
if (op != null) {
currentOut = op.pipe;
if (!currentOut.checkWrite()) {
op.active = false;
currentOut = null;
if (mandatory) {
moreOut = false;
errno.set(ZError.EAGAIN);
return false;
}
}
}
else if (mandatory) {
moreOut = false;
errno.set(ZError.EHOSTUNREACH);
return false;
}
}
return true;
}
// Check whether this is the last part of the message.
moreOut = msg.hasMore();
// Push the message into the pipe. If there's no out pipe, just drop it.
if (currentOut != null) {
boolean ok = currentOut.write(msg);
if (!ok) {
currentOut = null;
}
else if (!moreOut) {
currentOut.flush();
currentOut = null;
}
}
return true;
}
@Override
protected Msg xrecv()
{
Msg msg = null;
if (prefetched) {
if (!identitySent) {
msg = prefetchedId;
prefetchedId = null;
identitySent = true;
}
else {
msg = prefetchedMsg;
prefetchedMsg = null;
prefetched = false;
}
moreIn = msg.hasMore();
return msg;
}
ValueReference pipe = new ValueReference();
msg = fq.recvPipe(errno, pipe);
// It's possible that we receive peer's identity. That happens
// after reconnection. The current implementation assumes that
// the peer always uses the same identity.
// TODO: handle the situation when the peer changes its identity.
while (msg != null && msg.isIdentity()) {
msg = fq.recvPipe(errno, pipe);
}
if (msg == null) {
return null;
}
assert (pipe.get() != null);
// If we are in the middle of reading a message, just return the next part.
if (moreIn) {
moreIn = msg.hasMore();
}
else {
// We are at the beginning of a message.
// Keep the message part we have in the prefetch buffer
// and return the ID of the peer instead.
prefetchedMsg = msg;
prefetched = true;
Blob identity = pipe.get().getIdentity();
msg = new Msg(identity.data());
msg.setFlags(Msg.MORE);
identitySent = true;
}
return msg;
}
// Rollback any message parts that were sent but not yet flushed.
protected void rollback()
{
if (currentOut != null) {
currentOut.rollback();
currentOut = null;
moreOut = false;
}
}
@Override
protected boolean xhasIn()
{
// If we are in the middle of reading the messages, there are
// definitely more parts available.
if (moreIn) {
return true;
}
// We may already have a message pre-fetched.
if (prefetched) {
return true;
}
// Try to read the next message.
// The message, if read, is kept in the pre-fetch buffer.
ValueReference pipe = new ValueReference();
prefetchedMsg = fq.recvPipe(errno, pipe);
// It's possible that we receive peer's identity. That happens
// after reconnection. The current implementation assumes that
// the peer always uses the same identity.
// TODO: handle the situation when the peer changes its identity.
while (prefetchedMsg != null && prefetchedMsg.isIdentity()) {
prefetchedMsg = fq.recvPipe(errno, pipe);
}
if (prefetchedMsg == null) {
return false;
}
assert (pipe.get() != null);
Blob identity = pipe.get().getIdentity();
prefetchedId = new Msg(identity.data());
prefetchedId.setFlags(Msg.MORE);
prefetched = true;
identitySent = false;
return true;
}
@Override
protected boolean xhasOut()
{
// In theory, ROUTER socket is always ready for writing. Whether actual
// attempt to write succeeds depends on whitch pipe the message is going
// to be routed to.
return true;
}
private boolean identifyPeer(Pipe pipe)
{
Blob identity;
Msg msg = pipe.read();
if (msg == null) {
return false;
}
if (msg.size() == 0) {
// Fall back on the auto-generation
ByteBuffer buf = ByteBuffer.allocate(5);
buf.put((byte) 0);
buf.putInt(nextPeerId++);
identity = Blob.createBlob(buf.array(), false);
}
else {
identity = Blob.createBlob(msg.data(), true);
if (outpipes.containsKey(identity)) {
if (!handover) {
return false;
}
// We will allow the new connection to take over this
// identity. Temporarily assign a new identity to the
// existing pipe so we can terminate it asynchronously.
ByteBuffer buf = ByteBuffer.allocate(5);
buf.put((byte) 0);
buf.putInt(nextPeerId++);
Blob newIdentity = Blob.createBlob(buf.array(), false);
// Remove the existing identity entry to allow the new
// connection to take the identity.
Outpipe existingOutpipe = outpipes.remove(identity);
existingOutpipe.pipe.setIdentity(newIdentity);
outpipes.put(newIdentity, existingOutpipe);
existingOutpipe.pipe.terminate(true);
}
}
pipe.setIdentity(identity);
// Add the record into output pipes lookup table
Outpipe outpipe = new Outpipe(pipe, true);
outpipes.put(identity, outpipe);
return true;
}
}
jeromq-0.3.5/src/main/java/zmq/SessionBase.java 0000664 0000000 0000000 00000035024 12551504772 0021354 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 terminatingPipes;
// This flag is true if the remainder of the message being processed
// is still in the in pipe.
private boolean incompleteIn;
// True if termination have been suspended to push the pending
// messages to the network.
private boolean pending;
// The protocol I/O engine connected to the session.
private IEngine engine;
// The socket the session belongs to.
protected SocketBase socket;
// I/O thread the session is living in. It will be used to plug in
// the engines into the same thread.
private IOThread ioThread;
// ID of the linger timer
private static final int LINGER_TIMER_ID = 0x20;
// True is linger timer is running.
private boolean hasLingerTimer;
// If true, identity has been sent/received from the network.
private boolean identitySent;
private boolean identityReceived;
// Protocol and address to use when connecting.
private final Address addr;
private IOObject ioObject;
public static SessionBase create(IOThread ioThread, boolean connect,
SocketBase socket, Options options, Address addr)
{
SessionBase s = null;
switch (options.type) {
case ZMQ.ZMQ_REQ:
s = new Req.ReqSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_DEALER:
s = new Dealer.DealerSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_REP:
s = new Rep.RepSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_ROUTER:
s = new Router.RouterSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_PUB:
s = new Pub.PubSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_XPUB:
s = new XPub.XPubSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_SUB:
s = new Sub.SubSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_XSUB:
s = new XSub.XSubSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_PUSH:
s = new Push.PushSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_PULL:
s = new Pull.PullSession(ioThread, connect,
socket, options, addr);
break;
case ZMQ.ZMQ_PAIR:
s = new Pair.PairSession(ioThread, connect,
socket, options, addr);
break;
default:
throw new IllegalArgumentException("type=" + options.type);
}
return s;
}
public SessionBase(IOThread ioThread, boolean connect,
SocketBase socket, Options options, Address addr)
{
super(ioThread, options);
ioObject = new IOObject(ioThread);
this.connect = connect;
pipe = null;
incompleteIn = false;
pending = false;
engine = null;
this.socket = socket;
this.ioThread = ioThread;
hasLingerTimer = false;
identitySent = false;
identityReceived = false;
this.addr = addr;
terminatingPipes = new HashSet();
}
@Override
public void destroy()
{
assert (pipe == null);
// If there's still a pending linger timer, remove it.
if (hasLingerTimer) {
ioObject.cancelTimer(LINGER_TIMER_ID);
hasLingerTimer = false;
}
// Close the engine.
if (engine != null) {
engine.terminate();
}
}
// To be used once only, when creating the session.
public void attachPipe(Pipe pipe)
{
assert (!isTerminating());
assert (this.pipe == null);
assert (pipe != null);
this.pipe = pipe;
this.pipe.setEventSink(this);
}
public Msg pullMsg()
{
// First message to send is identity
if (!identitySent) {
Msg msg = new Msg(options.identitySize);
msg.put(options.identity, 0, options.identitySize);
identitySent = true;
incompleteIn = false;
return msg;
}
if (pipe == null) {
return null;
}
Msg msg = pipe.read();
if (msg == null) {
return null;
}
incompleteIn = msg.hasMore();
return msg;
}
@Override
public int pushMsg(Msg msg)
{
// First message to receive is identity (if required).
if (!identityReceived) {
msg.setFlags(Msg.IDENTITY);
identityReceived = true;
if (!options.recvIdentity) {
return 0;
}
}
if (pipe != null && pipe.write(msg)) {
return 0;
}
return ZError.EAGAIN;
}
protected void reset()
{
// Restore identity flags.
identitySent = false;
identityReceived = false;
}
public void flush()
{
if (pipe != null) {
pipe.flush();
}
}
// Remove any half processed messages. Flush unflushed messages.
// Call this function when engine disconnect to get rid of leftovers.
private void cleanPipes()
{
if (pipe != null) {
// Get rid of half-processed messages in the out pipe. Flush any
// unflushed messages upstream.
pipe.rollback();
pipe.flush();
// Remove any half-read message from the in pipe.
while (incompleteIn) {
Msg msg = pullMsg();
if (msg == null) {
assert (!incompleteIn);
break;
}
// msg.close ();
}
}
}
@Override
public void pipeTerminated(Pipe pipe)
{
// Drop the reference to the deallocated pipe.
assert (this.pipe == pipe || terminatingPipes.contains(pipe));
if (this.pipe == pipe) {
// If this is our current pipe, remove it
this.pipe = null;
if (hasLingerTimer) {
ioObject.cancelTimer(LINGER_TIMER_ID);
hasLingerTimer = false;
}
}
else {
// Remove the pipe from the detached pipes set
terminatingPipes.remove(pipe);
}
// If we are waiting for pending messages to be sent, at this point
// we are sure that there will be no more messages and we can proceed
// with termination safely.
if (pending && this.pipe == null && terminatingPipes.isEmpty()) {
pending = false;
super.processTerm(0);
}
}
@Override
public void readActivated(Pipe pipe)
{
// Skip activating if we're detaching this pipe
if (this.pipe != pipe) {
assert (terminatingPipes.contains(pipe));
return;
}
if (engine != null) {
engine.activateOut();
}
else {
this.pipe.checkRead();
}
}
@Override
public void writeActivated(Pipe pipe)
{
// Skip activating if we're detaching this pipe
if (this.pipe != pipe) {
assert (terminatingPipes.contains(pipe));
return;
}
if (engine != null) {
engine.activateIn();
}
}
@Override
public void hiccuped(Pipe pipe)
{
// Hiccups are always sent from session to socket, not the other
// way round.
throw new UnsupportedOperationException("Must Override");
}
public SocketBase getSocket()
{
return socket;
}
@Override
protected void processPlug()
{
ioObject.setHandler(this);
if (connect) {
startConnecting(false);
}
}
@Override
protected void processAttach(IEngine engine)
{
assert (engine != null);
// Create the pipe if it does not exist yet.
if (pipe == null && !isTerminating()) {
ZObject[] parents = {this, socket};
Pipe[] pipes = {null, null};
int[] hwms = {options.recvHwm, options.sendHwm};
boolean[] delays = {options.delayOnClose, options.delayOnDisconnect};
Pipe.pipepair(parents, pipes, hwms, delays);
// Plug the local end of the pipe.
pipes[0].setEventSink(this);
// Remember the local end of the pipe.
assert (pipe == null);
pipe = pipes[0];
// Ask socket to plug into the remote end of the pipe.
sendBind(socket, pipes[1]);
}
// Plug in the engine.
assert (this.engine == null);
this.engine = engine;
this.engine.plug(ioThread, this);
}
public void detach()
{
// Engine is dead. Let's forget about it.
engine = null;
// Remove any half-done messages from the pipes.
cleanPipes();
// Send the event to the derived class.
detached();
// Just in case there's only a delimiter in the pipe.
if (pipe != null) {
pipe.checkRead();
}
}
protected void processTerm(int linger)
{
assert (!pending);
// If the termination of the pipe happens before the term command is
// delivered there's nothing much to do. We can proceed with the
// stadard termination immediately.
if (pipe == null && terminatingPipes.isEmpty()) {
super.processTerm(0);
return;
}
pending = true;
// If there's finite linger value, delay the termination.
// If linger is infinite (negative) we don't even have to set
// the timer.
if (linger > 0) {
assert (!hasLingerTimer);
ioObject.addTimer(linger, LINGER_TIMER_ID);
hasLingerTimer = true;
}
// Start pipe termination process. Delay the termination till all messages
// are processed in case the linger time is non-zero.
if (pipe != null) {
pipe.terminate(linger != 0);
// TODO: Should this go into pipe_t::terminate ?
// In case there's no engine and there's only delimiter in the
// pipe it wouldn't be ever read. Thus we check for it explicitly.
pipe.checkRead();
}
}
@Override
public void timerEvent(int id)
{
// Linger period expired. We can proceed with termination even though
// there are still pending messages to be sent.
assert (id == LINGER_TIMER_ID);
hasLingerTimer = false;
// Ask pipe to terminate even though there may be pending messages in it.
assert (pipe != null);
pipe.terminate(false);
}
private void detached()
{
// Transient session self-destructs after peer disconnects.
if (!connect) {
terminate();
return;
}
// For delayed connect situations, terminate the pipe
// and reestablish later on
if (pipe != null && options.delayAttachOnConnect == 1
&& !addr.protocol().equals("pgm") && !addr.protocol().equals("epgm")) {
pipe.hiccup();
pipe.terminate(false);
terminatingPipes.add(pipe);
pipe = null;
}
reset();
// Reconnect.
if (options.reconnectIvl != -1) {
startConnecting(true);
}
// For subscriber sockets we hiccup the inbound pipe, which will cause
// the socket object to resend all the subscriptions.
if (pipe != null && (options.type == ZMQ.ZMQ_SUB || options.type == ZMQ.ZMQ_XSUB)) {
pipe.hiccup();
}
}
private void startConnecting(boolean wait)
{
assert (connect);
// Choose I/O thread to run connecter in. Given that we are already
// running in an I/O thread, there must be at least one available.
IOThread ioThread = chooseIoThread(options.affinity);
assert (ioThread != null);
// Create the connecter object.
if (addr.protocol().equals("tcp")) {
TcpConnecter connecter = new TcpConnecter(
ioThread, this, options, addr, wait);
launchChild(connecter);
return;
}
if (addr.protocol().equals("ipc")) {
IpcConnecter connecter = new IpcConnecter(
ioThread, this, options, addr, wait);
launchChild(connecter);
return;
}
assert (false);
}
@Override
public String toString()
{
return super.toString() + "[" + options.socketId + "]";
}
@Override
public void inEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void outEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void connectEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void acceptEvent()
{
throw new UnsupportedOperationException();
}
}
jeromq-0.3.5/src/main/java/zmq/Signaler.java 0000664 0000000 0000000 00000011134 12551504772 0020676 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 endpoints;
// Map of open inproc endpoints.
private final Map inprocs;
// Used to check whether the object is a socket.
private int tag;
// If true, associated context was already terminated.
private boolean ctxTerminated;
// If true, object should have been already destroyed. However,
// destruction is delayed while we unwind the stack to the point
// where it doesn't intersect the object being destroyed.
private boolean destroyed;
// Socket's mailbox object.
private final Mailbox mailbox;
// List of attached pipes.
private final List pipes;
// Reaper's poller and handle of this socket within it.
private Poller poller;
private SelectableChannel handle;
// Timestamp of when commands were processed the last time.
private long lastTsc;
// Number of messages received since last command processing.
private int ticks;
// True if the last message received had MORE flag set.
private boolean rcvmore;
// Monitor socket
private SocketBase monitorSocket;
// Bitmask of events being monitored
private int monitorEvents;
protected ValueReference errno;
protected SocketBase(Ctx parent, int tid, int sid)
{
super(parent, tid);
tag = 0xbaddecaf;
ctxTerminated = false;
destroyed = false;
lastTsc = 0;
ticks = 0;
rcvmore = false;
monitorSocket = null;
monitorEvents = 0;
options.socketId = sid;
options.linger = parent.get(ZMQ.ZMQ_BLOCKY) != 0 ? -1 : 0;
endpoints = new MultiMap();
inprocs = new MultiMap();
pipes = new ArrayList();
mailbox = new Mailbox("socket-" + sid);
errno = new ValueReference(0);
}
// Concrete algorithms for the x- methods are to be defined by
// individual socket types.
protected abstract void xattachPipe(Pipe pipe, boolean icanhasall);
protected abstract void xpipeTerminated(Pipe pipe);
// Returns false if object is not a socket.
public boolean checkTag()
{
return tag == 0xbaddecaf;
}
// Create a socket of a specified type.
public static SocketBase create(int type, Ctx parent, int tid, int sid)
{
SocketBase s = null;
switch (type) {
case ZMQ.ZMQ_PAIR:
s = new Pair(parent, tid, sid);
break;
case ZMQ.ZMQ_PUB:
s = new Pub(parent, tid, sid);
break;
case ZMQ.ZMQ_SUB:
s = new Sub(parent, tid, sid);
break;
case ZMQ.ZMQ_REQ:
s = new Req(parent, tid, sid);
break;
case ZMQ.ZMQ_REP:
s = new Rep(parent, tid, sid);
break;
case ZMQ.ZMQ_DEALER:
s = new Dealer(parent, tid, sid);
break;
case ZMQ.ZMQ_ROUTER:
s = new Router(parent, tid, sid);
break;
case ZMQ.ZMQ_PULL:
s = new Pull(parent, tid, sid);
break;
case ZMQ.ZMQ_PUSH:
s = new Push(parent, tid, sid);
break;
case ZMQ.ZMQ_XPUB:
s = new XPub(parent, tid, sid);
break;
case ZMQ.ZMQ_XSUB:
s = new XSub(parent, tid, sid);
break;
default:
throw new IllegalArgumentException("type=" + type);
}
return s;
}
public void destroy()
{
try {
mailbox.close();
}
catch (IOException ignore) {
}
stopMonitor();
assert (destroyed);
}
// Returns the mailbox associated with this socket.
public Mailbox getMailbox()
{
return mailbox;
}
// Interrupt blocking call if the socket is stuck in one.
// This function can be called from a different thread!
public void stop()
{
// Called by ctx when it is terminated (zmq_term).
// 'stop' command is sent from the threads that called zmq_term to
// the thread owning the socket. This way, blocking call in the
// owner thread can be interrupted.
sendStop();
}
// Check whether transport protocol, as specified in connect or
// bind, is available and compatible with the socket type.
private void checkProtocol(String protocol)
{
// First check out whether the protcol is something we are aware of.
if (!protocol.equals("inproc") && !protocol.equals("ipc") && !protocol.equals("tcp") /*&&
!protocol.equals("pgm") && !protocol.equals("epgm")*/) {
throw new UnsupportedOperationException(protocol);
}
// Check whether socket type and transport protocol match.
// Specifically, multicast protocols can't be combined with
// bi-directional messaging patterns (socket types).
if ((protocol.equals("pgm") || protocol.equals("epgm")) &&
options.type != ZMQ.ZMQ_PUB && options.type != ZMQ.ZMQ_SUB &&
options.type != ZMQ.ZMQ_XPUB && options.type != ZMQ.ZMQ_XSUB) {
throw new UnsupportedOperationException(protocol + ",type=" + options.type);
}
// Protocol is available.
}
// Register the pipe with this socket.
private void attachPipe(Pipe pipe)
{
attachPipe(pipe, false);
}
private void attachPipe(Pipe pipe, boolean icanhasall)
{
// First, register the pipe so that we can terminate it later on.
pipe.setEventSink(this);
pipes.add(pipe);
// Let the derived socket type know about new pipe.
xattachPipe(pipe, icanhasall);
// If the socket is already being closed, ask any new pipes to terminate
// straight away.
if (isTerminating()) {
registerTermAcks(1);
pipe.terminate(false);
}
}
public void setSocketOpt(int option, Object optval)
{
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// First, check whether specific socket type overloads the option.
if (xsetsockopt(option, optval)) {
return;
}
// If the socket type doesn't support the option, pass it to
// the generic option parser.
options.setSocketOpt(option, optval);
}
public int getSocketOpt(int option)
{
if (option != ZMQ.ZMQ_EVENTS && ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// fast track to avoid boxing
if (option == ZMQ.ZMQ_RCVMORE) {
return rcvmore ? 1 : 0;
}
if (option == ZMQ.ZMQ_EVENTS) {
boolean rc = processCommands(0, false);
if (!rc && errno.get() == ZError.ETERM) {
return -1;
}
assert (rc);
int val = 0;
if (hasOut()) {
val |= ZMQ.ZMQ_POLLOUT;
}
if (hasIn()) {
val |= ZMQ.ZMQ_POLLIN;
}
return val;
}
return (Integer) getsockoptx(option);
}
public Object getsockoptx(int option)
{
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
if (option == ZMQ.ZMQ_RCVMORE) {
return rcvmore ? 1 : 0;
}
if (option == ZMQ.ZMQ_FD) {
return mailbox.getFd();
}
if (option == ZMQ.ZMQ_EVENTS) {
boolean rc = processCommands(0, false);
if (!rc && errno.get() == ZError.ETERM) {
return -1;
}
assert (rc);
int val = 0;
if (hasOut()) {
val |= ZMQ.ZMQ_POLLOUT;
}
if (hasIn()) {
val |= ZMQ.ZMQ_POLLIN;
}
return val;
}
// If the socket type doesn't support the option, pass it to
// the generic option parser.
return options.getsockopt(option);
}
public boolean bind(final String addr)
{
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// Process pending commands, if any.
boolean brc = processCommands(0, false);
if (!brc) {
return false;
}
// Parse addr_ string.
URI uri;
try {
uri = new URI(addr);
}
catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
String protocol = uri.getScheme();
String address = uri.getAuthority();
String path = uri.getPath();
if (address == null) {
address = path;
}
checkProtocol(protocol);
if (protocol.equals("inproc")) {
Ctx.Endpoint endpoint = new Ctx.Endpoint(this, options);
boolean rc = registerEndpoint(addr, endpoint);
if (rc) {
// Save last endpoint URI
options.lastEndpoint = addr;
}
else {
errno.set(ZError.EADDRINUSE);
}
return rc;
}
if (protocol.equals("pgm") || protocol.equals("epgm")) {
// For convenience's sake, bind can be used interchageable with
// connect for PGM and EPGM transports.
return connect(addr);
}
// Remaining trasnports require to be run in an I/O thread, so at this
// point we'll choose one.
IOThread ioThread = chooseIoThread(options.affinity);
if (ioThread == null) {
throw new IllegalStateException("EMTHREAD");
}
if (protocol.equals("tcp")) {
TcpListener listener = new TcpListener(ioThread, this, options);
int rc = listener.setAddress(address);
if (rc != 0) {
listener.destroy();
eventBindFailed(address, rc);
errno.set(rc);
return false;
}
// Save last endpoint URI
options.lastEndpoint = listener.getAddress();
addEndpoint(options.lastEndpoint, listener);
return true;
}
if (protocol.equals("ipc")) {
IpcListener listener = new IpcListener(ioThread, this, options);
int rc = listener.setAddress(address);
if (rc != 0) {
listener.destroy();
eventBindFailed(address, rc);
errno.set(rc);
return false;
}
// Save last endpoint URI
options.lastEndpoint = listener.getAddress();
addEndpoint(addr, listener);
return true;
}
throw new IllegalArgumentException(addr);
}
public boolean connect(String addr)
{
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// Process pending commands, if any.
boolean brc = processCommands(0, false);
if (!brc) {
return false;
}
// Parse addr_ string.
URI uri;
try {
uri = new URI(addr);
}
catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
String protocol = uri.getScheme();
String address = uri.getAuthority();
String path = uri.getPath();
if (address == null) {
address = path;
}
checkProtocol(protocol);
if (protocol.equals("inproc")) {
// TODO: inproc connect is specific with respect to creating pipes
// as there's no 'reconnect' functionality implemented. Once that
// is in place we should follow generic pipe creation algorithm.
// Find the peer endpoint.
Ctx.Endpoint peer = findEndpoint(addr);
if (peer.socket == null) {
return false;
}
// The total HWM for an inproc connection should be the sum of
// the binder's HWM and the connector's HWM.
int sndhwm = 0;
if (options.sendHwm != 0 && peer.options.recvHwm != 0) {
sndhwm = options.sendHwm + peer.options.recvHwm;
}
int rcvhwm = 0;
if (options.recvHwm != 0 && peer.options.sendHwm != 0) {
rcvhwm = options.recvHwm + peer.options.sendHwm;
}
// Create a bi-directional pipe to connect the peers.
ZObject[] parents = {this, peer.socket};
Pipe[] pipes = {null, null};
int[] hwms = {sndhwm, rcvhwm};
boolean[] delays = {options.delayOnDisconnect, options.delayOnClose};
Pipe.pipepair(parents, pipes, hwms, delays);
// Attach local end of the pipe to this socket object.
attachPipe(pipes[0]);
// If required, send the identity of the peer to the local socket.
if (peer.options.recvIdentity) {
Msg id = new Msg(options.identitySize);
id.put(options.identity, 0 , options.identitySize);
id.setFlags(Msg.IDENTITY);
boolean written = pipes[0].write(id);
assert (written);
pipes[0].flush();
}
// If required, send the identity of the local socket to the peer.
if (options.recvIdentity) {
Msg id = new Msg(peer.options.identitySize);
id.put(peer.options.identity, 0 , peer.options.identitySize);
id.setFlags(Msg.IDENTITY);
boolean written = pipes[1].write(id);
assert (written);
pipes[1].flush();
}
// Attach remote end of the pipe to the peer socket. Note that peer's
// seqnum was incremented in findEndpoint function. We don't need it
// increased here.
sendBind(peer.socket, pipes[1], false);
// Save last endpoint URI
options.lastEndpoint = addr;
// remember inproc connections for disconnect
inprocs.put(addr, pipes[0]);
return true;
}
// Choose the I/O thread to run the session in.
IOThread ioThread = chooseIoThread(options.affinity);
if (ioThread == null) {
throw new IllegalStateException("Empty IO Thread");
}
boolean ipv4only = options.ipv4only != 0;
Address paddr = new Address(protocol, address, ipv4only);
// Resolve address (if needed by the protocol)
paddr.resolve();
// Create session.
SessionBase session = SessionBase.create(ioThread, true, this,
options, paddr);
assert (session != null);
// PGM does not support subscription forwarding; ask for all data to be
// sent to this pipe.
boolean icanhasall = false;
if (protocol.equals("pgm") || protocol.equals("epgm")) {
icanhasall = true;
}
if (options.delayAttachOnConnect != 1 || icanhasall) {
// Create a bi-directional pipe.
ZObject[] parents = {this, session};
Pipe[] pipes = {null, null};
int[] hwms = {options.sendHwm, options.recvHwm};
boolean[] delays = {options.delayOnDisconnect, options.delayOnClose};
Pipe.pipepair(parents, pipes, hwms, delays);
// Attach local end of the pipe to the socket object.
attachPipe(pipes[0], icanhasall);
// Attach remote end of the pipe to the session object later on.
session.attachPipe(pipes[1]);
}
// Save last endpoint URI
options.lastEndpoint = paddr.toString();
addEndpoint(addr, session);
return true;
}
// Creates new endpoint ID and adds the endpoint to the map.
private void addEndpoint(String addr, Own endpoint)
{
// Activate the session. Make it a child of this socket.
launchChild(endpoint);
endpoints.put(addr, endpoint);
}
public boolean termEndpoint(String addr)
{
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// Check whether endpoint address passed to the function is valid.
if (addr == null) {
throw new IllegalArgumentException();
}
// Process pending commands, if any, since there could be pending unprocessed processOwn()'s
// (from launchChild() for example) we're asked to terminate now.
boolean rc = processCommands(0, false);
if (!rc) {
return false;
}
// Parse addr_ string.
URI uri;
try {
uri = new URI(addr);
}
catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
String protocol = uri.getScheme();
// Disconnect an inproc socket
if (protocol.equals("inproc")) {
if (!inprocs.containsKey(addr)) {
return false;
}
Iterator> it = inprocs.entrySet().iterator();
while (it.hasNext()) {
it.next().getValue().terminate(true);
it.remove();
}
return true;
}
if (!endpoints.containsKey(addr)) {
return false;
}
// Find the endpoints range (if any) corresponding to the addr_ string.
Iterator> it = endpoints.entrySet().iterator();
while (it.hasNext()) {
Entry e = it.next();
if (!e.getKey().equals(addr)) {
continue;
}
termChild(e.getValue());
it.remove();
}
return true;
}
public boolean send(Msg msg, int flags)
{
if (ctxTerminated) {
errno.set(ZError.ETERM);
return false;
}
// Check whether message passed to the function is valid.
if (msg == null) {
throw new IllegalArgumentException();
}
// Process pending commands, if any.
boolean brc = processCommands(0, true);
if (!brc) {
return false;
}
// Clear any user-visible flags that are set on the message.
msg.resetFlags(Msg.MORE);
// At this point we impose the flags on the message.
if ((flags & ZMQ.ZMQ_SNDMORE) > 0) {
msg.setFlags(Msg.MORE);
}
// Try to send the message.
boolean rc = xsend(msg);
if (rc) {
return true;
}
if (errno.get() != ZError.EAGAIN) {
return false;
}
// In case of non-blocking send we'll simply propagate
// the error - including EAGAIN - up the stack.
if ((flags & ZMQ.ZMQ_DONTWAIT) > 0 || options.sendTimeout == 0) {
return false;
}
// Compute the time when the timeout should occur.
// If the timeout is infite, don't care.
int timeout = options.sendTimeout;
long end = timeout < 0 ? 0 : (Clock.nowMS() + timeout);
// Oops, we couldn't send the message. Wait for the next
// command, process it and try to send the message again.
// If timeout is reached in the meantime, return EAGAIN.
while (true) {
if (!processCommands(timeout, false)) {
return false;
}
rc = xsend(msg);
if (rc) {
break;
}
if (errno.get() != ZError.EAGAIN) {
return false;
}
if (timeout > 0) {
timeout = (int) (end - Clock.nowMS());
if (timeout <= 0) {
errno.set(ZError.EAGAIN);
return false;
}
}
}
return true;
}
public Msg recv(int flags)
{
if (ctxTerminated) {
errno.set(ZError.ETERM);
return null;
}
// Once every inbound_poll_rate messages check for signals and process
// incoming commands. This happens only if we are not polling altogether
// because there are messages available all the time. If poll occurs,
// ticks is set to zero and thus we avoid this code.
//
// Note that 'recv' uses different command throttling algorithm (the one
// described above) from the one used by 'send'. This is because counting
// ticks is more efficient than doing RDTSC all the time.
if (++ticks == Config.INBOUND_POLL_RATE.getValue()) {
if (!processCommands(0, false)) {
return null;
}
ticks = 0;
}
// Get the message.
Msg msg = xrecv();
if (msg == null && errno.get() != ZError.EAGAIN) {
return null;
}
// If we have the message, return immediately.
if (msg != null) {
extractFlags(msg);
return msg;
}
// If the message cannot be fetched immediately, there are two scenarios.
// For non-blocking recv, commands are processed in case there's an
// activate_reader command already waiting int a command pipe.
// If it's not, return EAGAIN.
if ((flags & ZMQ.ZMQ_DONTWAIT) > 0 || options.recvTimeout == 0) {
if (!processCommands(0, false)) {
return null;
}
ticks = 0;
msg = xrecv();
if (msg == null) {
return null;
}
extractFlags(msg);
return msg;
}
// Compute the time when the timeout should occur.
// If the timeout is infite, don't care.
int timeout = options.recvTimeout;
long end = timeout < 0 ? 0 : (Clock.nowMS() + timeout);
// In blocking scenario, commands are processed over and over again until
// we are able to fetch a message.
boolean block = (ticks != 0);
while (true) {
if (!processCommands(block ? timeout : 0, false)) {
return null;
}
msg = xrecv();
if (msg != null) {
ticks = 0;
break;
}
if (errno.get() != ZError.EAGAIN) {
return null;
}
block = true;
if (timeout > 0) {
timeout = (int) (end - Clock.nowMS());
if (timeout <= 0) {
errno.set(ZError.EAGAIN);
return null;
}
}
}
extractFlags(msg);
return msg;
}
public void close()
{
// Mark the socket as dead
tag = 0xdeadbeef;
// Transfer the ownership of the socket from this application thread
// to the reaper thread which will take care of the rest of shutdown
// process.
sendReap(this);
}
// These functions are used by the polling mechanism to determine
// which events are to be reported from this socket.
boolean hasIn()
{
return xhasIn();
}
boolean hasOut()
{
return xhasOut();
}
// Using this function reaper thread ask the socket to register with
// its poller.
public void startReaping(Poller poller)
{
// Plug the socket to the reaper thread.
this.poller = poller;
handle = mailbox.getFd();
this.poller.addHandle(handle, this);
this.poller.setPollIn(handle);
// Initialise the termination and check whether it can be deallocated
// immediately.
terminate();
checkDestroy();
}
// Processes commands sent to this socket (if any). If timeout is -1,
// returns only after at least one command was processed.
// If throttle argument is true, commands are processed at most once
// in a predefined time period.
private boolean processCommands(int timeout, boolean throttle)
{
Command cmd;
if (timeout != 0) {
// If we are asked to wait, simply ask mailbox to wait.
cmd = mailbox.recv(timeout);
}
else {
// If we are asked not to wait, check whether we haven't processed
// commands recently, so that we can throttle the new commands.
// Get the CPU's tick counter. If 0, the counter is not available.
long tsc = 0; // save cpu Clock.rdtsc ();
// Optimised version of command processing - it doesn't have to check
// for incoming commands each time. It does so only if certain time
// elapsed since last command processing. Command delay varies
// depending on CPU speed: It's ~1ms on 3GHz CPU, ~2ms on 1.5GHz CPU
// etc. The optimisation makes sense only on platforms where getting
// a timestamp is a very cheap operation (tens of nanoseconds).
if (tsc != 0 && throttle) {
// Check whether TSC haven't jumped backwards (in case of migration
// between CPU cores) and whether certain time have elapsed since
// last command processing. If it didn't do nothing.
if (tsc >= lastTsc && tsc - lastTsc <= Config.MAX_COMMAND_DELAY.getValue()) {
return true;
}
lastTsc = tsc;
}
// Check whether there are any commands pending for this thread.
cmd = mailbox.recv(0);
}
// Process all the commands available at the moment.
while (true) {
if (cmd == null) {
break;
}
cmd.destination().processCommand(cmd);
cmd = mailbox.recv(0);
}
if (ctxTerminated) {
errno.set(ZError.ETERM); // Do not raise exception at the blocked operation
return false;
}
return true;
}
@Override
protected void processStop()
{
// Here, someone have called zmq_term while the socket was still alive.
// We'll remember the fact so that any blocking call is interrupted and any
// further attempt to use the socket will return ETERM. The user is still
// responsible for calling zmq_close on the socket though!
stopMonitor();
ctxTerminated = true;
}
@Override
protected void processBind(Pipe pipe)
{
attachPipe(pipe);
}
@Override
protected void processTerm(int linger)
{
// Unregister all inproc endpoints associated with this socket.
// Doing this we make sure that no new pipes from other sockets (inproc)
// will be initiated.
unregisterEndpoints(this);
// Ask all attached pipes to terminate.
for (int i = 0; i != pipes.size(); ++i) {
pipes.get(i).terminate(false);
}
registerTermAcks(pipes.size());
// Continue the termination process immediately.
super.processTerm(linger);
}
// Delay actual destruction of the socket.
@Override
protected void processDestroy()
{
destroyed = true;
}
// The default implementation assumes there are no specific socket
// options for the particular socket type. If not so, overload this
// method.
protected boolean xsetsockopt(int option, Object optval)
{
return false;
}
protected boolean xhasOut()
{
return false;
}
protected boolean xsend(Msg msg)
{
throw new UnsupportedOperationException("Must Override");
}
protected boolean xhasIn()
{
return false;
}
protected Msg xrecv()
{
throw new UnsupportedOperationException("Must Override");
}
protected void xreadActivated(Pipe pipe)
{
throw new UnsupportedOperationException("Must Override");
}
protected void xwriteActivated(Pipe pipe)
{
throw new UnsupportedOperationException("Must Override");
}
protected void xhiccuped(Pipe pipe)
{
throw new UnsupportedOperationException("Must override");
}
@Override
public void inEvent()
{
// This function is invoked only once the socket is running in the context
// of the reaper thread. Process any commands from other threads/sockets
// that may be available at the moment. Ultimately, the socket will
// be destroyed.
try {
processCommands(0, false);
}
catch (ZError.CtxTerminatedException e) {
}
checkDestroy();
}
@Override
public void outEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void connectEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void acceptEvent()
{
throw new UnsupportedOperationException();
}
@Override
public void timerEvent(int id)
{
throw new UnsupportedOperationException();
}
// To be called after processing commands or invoking any command
// handlers explicitly. If required, it will deallocate the socket.
private void checkDestroy()
{
// If the object was already marked as destroyed, finish the deallocation.
if (destroyed) {
// Remove the socket from the reaper's poller.
poller.removeHandle(handle);
// Remove the socket from the context.
destroySocket(this);
// Notify the reaper about the fact.
sendReaped();
// Deallocate.
super.processDestroy();
}
}
@Override
public void readActivated(Pipe pipe)
{
xreadActivated(pipe);
}
@Override
public void writeActivated(Pipe pipe)
{
xwriteActivated(pipe);
}
@Override
public void hiccuped(Pipe pipe)
{
if (options.delayAttachOnConnect == 1) {
pipe.terminate(false);
}
else {
// Notify derived sockets of the hiccup
xhiccuped(pipe);
}
}
@Override
public void pipeTerminated(Pipe pipe)
{
// Notify the specific socket type about the pipe termination.
xpipeTerminated(pipe);
// Remove pipe from inproc pipes
Iterator> it = inprocs.entrySet().iterator();
while (it.hasNext()) {
if (it.next().getValue() == pipe) {
it.remove();
break;
}
}
// Remove the pipe from the list of attached pipes and confirm its
// termination if we are already shutting down.
pipes.remove(pipe);
if (isTerminating()) {
unregisterTermAck();
}
}
// Moves the flags from the message to local variables,
// to be later retrieved by getSocketOpt.
private void extractFlags(Msg msg)
{
// Test whether IDENTITY flag is valid for this socket type.
if ((msg.flags() & Msg.IDENTITY) > 0) {
assert (options.recvIdentity);
}
// Remove MORE flag.
rcvmore = msg.hasMore();
}
public boolean monitor(final String addr, int events)
{
boolean rc;
if (ctxTerminated) {
throw new ZError.CtxTerminatedException();
}
// Support deregistering monitoring endpoints as well
if (addr == null) {
stopMonitor();
return true;
}
// Parse addr_ string.
URI uri;
try {
uri = new URI(addr);
}
catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
String protocol = uri.getScheme();
String address = uri.getAuthority();
String path = uri.getPath();
if (address == null) {
address = path;
}
checkProtocol(protocol);
// Event notification only supported over inproc://
if (!protocol.equals("inproc")) {
stopMonitor();
throw new IllegalArgumentException("inproc socket required");
}
// Register events to monitor
monitorEvents = events;
monitorSocket = getCtx().createSocket(ZMQ.ZMQ_PAIR);
if (monitorSocket == null) {
return false;
}
// Never block context termination on pending event messages
int linger = 0;
try {
monitorSocket.setSocketOpt(ZMQ.ZMQ_LINGER, linger);
}
catch (IllegalArgumentException e) {
stopMonitor();
throw e;
}
// Spawn the monitor socket endpoint
rc = monitorSocket.bind(addr);
if (!rc) {
stopMonitor();
}
return rc;
}
public void eventConnected(String addr, SelectableChannel ch)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_CONNECTED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_CONNECTED, addr, ch));
}
public void eventConnectDelayed(String addr, int errno)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_CONNECT_DELAYED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_CONNECT_DELAYED, addr, errno));
}
public void eventConnectRetried(String addr, int interval)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_CONNECT_RETRIED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_CONNECT_RETRIED, addr, interval));
}
public void eventListening(String addr, SelectableChannel ch)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_LISTENING) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_LISTENING, addr, ch));
}
public void eventBindFailed(String addr, int errno)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_BIND_FAILED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_BIND_FAILED, addr, errno));
}
public void eventAccepted(String addr, SelectableChannel ch)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_ACCEPTED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_ACCEPTED, addr, ch));
}
public void eventAcceptFailed(String addr, int errno)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_ACCEPT_FAILED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_ACCEPT_FAILED, addr, errno));
}
public void eventClosed(String addr, SelectableChannel ch)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_CLOSED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_CLOSED, addr, ch));
}
public void eventCloseFailed(String addr, int errno)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_CLOSE_FAILED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_CLOSE_FAILED, addr, errno));
}
public void eventDisconnected(String addr, SelectableChannel ch)
{
if ((monitorEvents & ZMQ.ZMQ_EVENT_DISCONNECTED) == 0) {
return;
}
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_DISCONNECTED, addr, ch));
}
protected void monitorEvent(ZMQ.Event event)
{
if (monitorSocket == null) {
return;
}
event.write(monitorSocket);
}
protected void stopMonitor()
{
if (monitorSocket != null) {
if ((monitorEvents & ZMQ.ZMQ_EVENT_MONITOR_STOPPED) != 0) {
monitorEvent(new ZMQ.Event(ZMQ.ZMQ_EVENT_MONITOR_STOPPED, "", 0));
}
monitorSocket.close();
monitorSocket = null;
monitorEvents = 0;
}
}
@Override
public String toString()
{
return super.toString() + "[" + options.socketId + "]";
}
public SelectableChannel getFD()
{
return mailbox.getFd();
}
public String typeString()
{
switch (options.type) {
case ZMQ.ZMQ_PAIR:
return "PAIR";
case ZMQ.ZMQ_PUB:
return "PUB";
case ZMQ.ZMQ_SUB:
return "SUB";
case ZMQ.ZMQ_REQ:
return "REQ";
case ZMQ.ZMQ_REP:
return "REP";
case ZMQ.ZMQ_DEALER:
return "DEALER";
case ZMQ.ZMQ_ROUTER:
return "ROUTER";
case ZMQ.ZMQ_PULL:
return "PULL";
case ZMQ.ZMQ_PUSH:
return "PUSH";
default:
return "UNKOWN";
}
}
public int errno()
{
return errno.get();
}
}
jeromq-0.3.5/src/main/java/zmq/StreamEngine.java 0000664 0000000 0000000 00000046610 12551504772 0021522 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 T[] realloc(Class klass, T[] src, int size, boolean ended)
{
T[] dest;
if (size > src.length) {
dest = (T[]) Array.newInstance(klass, size);
if (ended) {
System.arraycopy(src, 0, dest, 0, src.length);
}
else {
System.arraycopy(src, 0, dest, size - src.length, src.length);
}
}
else if (size < src.length) {
dest = (T[]) Array.newInstance(klass, size);
if (ended) {
System.arraycopy(src, src.length - size, dest, 0, size);
}
else {
System.arraycopy(src, 0, dest, 0, size);
}
}
else {
dest = src;
}
return dest;
}
public static void swap(List items, int index1, int index2)
{
if (index1 == index2) {
return;
}
T item1 = items.get(index1);
T item2 = items.get(index2);
if (item1 != null) {
items.set(index2, item1);
}
if (item2 != null) {
items.set(index1, item2);
}
}
public static byte[] bytes(ByteBuffer buf)
{
byte[] d = new byte[buf.limit()];
buf.get(d);
return d;
}
public static byte[] realloc(byte[] src, int size)
{
byte[] dest = new byte[size];
if (src != null) {
System.arraycopy(src, 0, dest, 0, src.length);
}
return dest;
}
public static boolean delete(File path)
{
if (!path.exists()) {
return false;
}
boolean ret = true;
if (path.isDirectory()) {
File[] files = path.listFiles();
if (files != null) {
for (File f : files) {
ret = ret && delete(f);
}
}
}
return ret && path.delete();
}
}
jeromq-0.3.5/src/main/java/zmq/V1Decoder.java 0000664 0000000 0000000 00000011655 12551504772 0020716 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
{
private V value;
public ValueReference(V value)
{
this.value = value;
}
public ValueReference()
{
}
public final V get()
{
return value;
}
public final void set(V value)
{
this.value = value;
}
}
jeromq-0.3.5/src/main/java/zmq/XPub.java 0000664 0000000 0000000 00000015554 12551504772 0020022 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 pendingData;
private final Deque pendingFlags;
private static Mtrie.IMtrieHandler markAsMatching;
private static Mtrie.IMtrieHandler sendUnsubscription;
static {
markAsMatching = new Mtrie.IMtrieHandler()
{
@Override
public void invoke(Pipe pipe, byte[] data, int size, Object arg)
{
XPub self = (XPub) arg;
self.dist.match(pipe);
}
};
sendUnsubscription = new Mtrie.IMtrieHandler()
{
@Override
public void invoke(Pipe pipe, byte[] data, int size, Object arg)
{
XPub self = (XPub) arg;
if (self.options.type != ZMQ.ZMQ_PUB) {
// Place the unsubscription to the queue of pending (un)sunscriptions
// to be retrived by the user later on.
byte[] unsub = new byte[size + 1];
unsub[0] = 0;
System.arraycopy(data, 0, unsub, 1, size);
self.pendingData.add(Blob.createBlob(unsub, false));
self.pendingFlags.add(0);
}
}
};
}
public XPub(Ctx parent, int tid, int sid)
{
super(parent, tid, sid);
options.type = ZMQ.ZMQ_XPUB;
verbose = false;
more = false;
subscriptions = new Mtrie();
dist = new Dist();
pendingData = new ArrayDeque();
pendingFlags = new ArrayDeque();
}
@Override
protected void xattachPipe(Pipe pipe, boolean icanhasall)
{
assert (pipe != null);
dist.attach(pipe);
// If icanhasall_ is specified, the caller would like to subscribe
// to all data on this pipe, implicitly.
if (icanhasall) {
subscriptions.add(null, pipe);
}
// The pipe is active when attached. Let's read the subscriptions from
// it, if any.
xreadActivated(pipe);
}
@Override
protected void xreadActivated(Pipe pipe)
{
// There are some subscriptions waiting. Let's process them.
Msg sub = null;
while ((sub = pipe.read()) != null) {
// Apply the subscription to the trie
byte[] data = sub.data();
int size = sub.size();
if (size > 0 && (data[0] == 0 || data[0] == 1)) {
boolean unique;
if (data[0] == 0) {
unique = subscriptions.rm(data, 1, pipe);
}
else {
unique = subscriptions.add(data, 1, pipe);
}
// If the subscription is not a duplicate, store it so that it can be
// passed to used on next recv call. (Unsubscribe is not verbose.)
if (options.type == ZMQ.ZMQ_XPUB && (unique || (data[0] == 1 && verbose))) {
pendingData.add(Blob.createBlob(data, true));
pendingFlags.add(0);
}
}
else {
// Process user message coming upstream from xsub socket
pendingData.add(Blob.createBlob(data, true));
pendingFlags.add(sub.flags());
}
}
}
@Override
protected void xwriteActivated(Pipe pipe)
{
dist.activated(pipe);
}
@Override
public boolean xsetsockopt(int option, Object optval)
{
if (option != ZMQ.ZMQ_XPUB_VERBOSE) {
return false;
}
verbose = (Integer) optval == 1;
return true;
}
@Override
protected void xpipeTerminated(Pipe pipe)
{
// Remove the pipe from the trie. If there are topics that nobody
// is interested in anymore, send corresponding unsubscriptions
// upstream.
subscriptions.rm(pipe, sendUnsubscription, this);
dist.terminated(pipe);
}
@Override
protected boolean xsend(Msg msg)
{
boolean msgMore = msg.hasMore();
// For the first part of multi-part message, find the matching pipes.
if (!more) {
subscriptions.match(msg.data(), msg.size(),
markAsMatching, this);
}
// Send the message to all the pipes that were marked as matching
// in the previous step.
boolean rc = dist.sendToMatching(msg);
if (!rc) {
return false;
}
// If we are at the end of multi-part message we can mark all the pipes
// as non-matching.
if (!msgMore) {
dist.unmatch();
}
more = msgMore;
return true;
}
@Override
protected boolean xhasOut()
{
return dist.hasOut();
}
@Override
protected Msg xrecv()
{
// If there is at least one
if (pendingData.isEmpty()) {
errno.set(ZError.EAGAIN);
return null;
}
Blob first = pendingData.pollFirst();
Msg msg = new Msg(first.data());
int flags = pendingFlags.pollFirst();
msg.setFlags(flags);
return msg;
}
@Override
protected boolean xhasIn()
{
return !pendingData.isEmpty();
}
}
jeromq-0.3.5/src/main/java/zmq/XSub.java 0000664 0000000 0000000 00000016423 12551504772 0020021 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
{
// Allocation-efficient queue to store pipe items.
// Front of the queue points to the first prefetched item, back of
// the pipe points to last un-flushed item. Front is used only by
// reader thread, while back is used only by writer thread.
private final YQueue queue;
// Points to the first un-flushed item. This variable is used
// exclusively by writer thread.
private int w;
// Points to the first un-prefetched item. This variable is used
// exclusively by reader thread.
private int r;
// Points to the first item to be flushed in the future.
private int f;
// The single point of contention between writer and reader thread.
// Points past the last flushed item. If it is NULL,
// reader is asleep. This pointer should be always accessed using
// atomic operations.
private final AtomicInteger c;
public YPipe(int qsize)
{
queue = new YQueue(qsize);
int pos = queue.backPos();
f = pos;
r = pos;
w = pos;
c = new AtomicInteger(queue.backPos());
}
// Write an item to the pipe. Don't flush it yet. If incomplete is
// set to true the item is assumed to be continued by items
// subsequently written to the pipe. Incomplete items are never
// flushed down the stream.
public void write(final T value, boolean incomplete)
{
// Place the value to the queue, add new terminator element.
queue.push(value);
// Move the "flush up to here" poiter.
if (!incomplete) {
f = queue.backPos();
}
}
// Pop an incomplete item from the pipe. Returns true is such
// item exists, false otherwise.
public T unwrite()
{
if (f == queue.backPos()) {
return null;
}
queue.unpush();
return queue.back();
}
// Flush all the completed items into the pipe. Returns false if
// the reader thread is sleeping. In that case, caller is obliged to
// wake the reader up before using the pipe again.
public boolean flush()
{
// If there are no un-flushed items, do nothing.
if (w == f) {
return true;
}
// Try to set 'c' to 'f'.
if (!c.compareAndSet(w, f)) {
// Compare-and-swap was unseccessful because 'c' is NULL.
// This means that the reader is asleep. Therefore we don't
// care about thread-safeness and update c in non-atomic
// manner. We'll return false to let the caller know
// that reader is sleeping.
c.set(f);
w = f;
return false;
}
// Reader is alive. Nothing special to do now. Just move
// the 'first un-flushed item' pointer to 'f'.
w = f;
return true;
}
// Check whether item is available for reading.
public boolean checkRead()
{
// Was the value prefetched already? If so, return.
int h = queue.frontPos();
if (h != r) {
return true;
}
// There's no prefetched value, so let us prefetch more values.
// Prefetching is to simply retrieve the
// pointer from c in atomic fashion. If there are no
// items to prefetch, set c to -1 (using compare-and-swap).
if (c.compareAndSet(h, -1)) {
// nothing to read, h == r must be the same
}
else {
// something to have been written
r = c.get();
}
// If there are no elements prefetched, exit.
// During pipe's lifetime r should never be NULL, however,
// it can happen during pipe shutdown when items
// are being deallocated.
if (h == r || r == -1) {
return false;
}
// There was at least one value prefetched.
return true;
}
// Reads an item from the pipe. Returns false if there is no value.
// available.
public T read()
{
// Try to prefetch a value.
if (!checkRead()) {
return null;
}
// There was at least one value prefetched.
// Return it to the caller.
return queue.pop();
}
// Applies the function fn to the first elemenent in the pipe
// and returns the value returned by the fn.
// The pipe mustn't be empty or the function crashes.
public T probe()
{
boolean rc = checkRead();
assert (rc);
return queue.front();
}
}
jeromq-0.3.5/src/main/java/zmq/YQueue.java 0000664 0000000 0000000 00000011671 12551504772 0020355 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
{
// Individual memory chunk to hold N elements.
private static class Chunk
{
final T[] values;
final int[] pos;
Chunk prev;
Chunk next;
@SuppressWarnings("unchecked")
public Chunk(int size, int memoryPtr)
{
values = (T[]) new Object[size];
pos = new int[size];
for (int i = 0; i != values.length; i++) {
pos[i] = memoryPtr;
memoryPtr++;
}
}
};
// Back position may point to invalid memory if the queue is empty,
// while begin & end positions are always valid. Begin position is
// accessed exclusively be queue reader (front/pop), while back and
// end positions are accessed exclusively by queue writer (back/push).
private Chunk beginChunk;
private int beginPos;
private Chunk backChunk;
private int backPos;
private Chunk endChunk;
private int endPos;
private volatile Chunk spareChunk;
private final int size;
// People are likely to produce and consume at similar rates. In
// this scenario holding onto the most recently freed chunk saves
// us from having to call malloc/free.
private int memoryPtr;
public YQueue(int size)
{
this.size = size;
memoryPtr = 0;
beginChunk = new Chunk(size, memoryPtr);
memoryPtr += size;
beginPos = 0;
backPos = 0;
backChunk = beginChunk;
spareChunk = beginChunk;
endChunk = beginChunk;
endPos = 1;
}
public int frontPos()
{
return beginChunk.pos[beginPos];
}
// Returns reference to the front element of the queue.
// If the queue is empty, behaviour is undefined.
public T front()
{
return beginChunk.values[beginPos];
}
public int backPos()
{
return backChunk.pos[backPos];
}
// Returns reference to the back element of the queue.
// If the queue is empty, behaviour is undefined.
public T back()
{
return backChunk.values[backPos];
}
public T pop()
{
T val = beginChunk.values[beginPos];
beginChunk.values[beginPos] = null;
beginPos++;
if (beginPos == size) {
beginChunk = beginChunk.next;
beginChunk.prev = null;
beginPos = 0;
}
return val;
}
// Adds an element to the back end of the queue.
public void push(T val)
{
backChunk.values[backPos] = val;
backChunk = endChunk;
backPos = endPos;
endPos++;
if (endPos != size) {
return;
}
Chunk sc = spareChunk;
if (sc != beginChunk) {
spareChunk = spareChunk.next;
endChunk.next = sc;
sc.prev = endChunk;
}
else {
endChunk.next = new Chunk(size, memoryPtr);
memoryPtr += size;
endChunk.next.prev = endChunk;
}
endChunk = endChunk.next;
endPos = 0;
}
// Removes element from the back end of the queue. In other words
// it rollbacks last push to the queue. Take care: Caller is
// responsible for destroying the object being unpushed.
// The caller must also guarantee that the queue isn't empty when
// unpush is called. It cannot be done automatically as the read
// side of the queue can be managed by different, completely
// unsynchronised thread.
public void unpush()
{
// First, move 'back' one position backwards.
if (backPos > 0) {
backPos--;
}
else {
backPos = size - 1;
backChunk = backChunk.prev;
}
// Now, move 'end' position backwards. Note that obsolete end chunk
// is not used as a spare chunk. The analysis shows that doing so
// would require free and atomic operation per chunk deallocated
// instead of a simple free.
if (endPos > 0) {
endPos--;
}
else {
endPos = size - 1;
endChunk = endChunk.prev;
endChunk.next = null;
}
}
}
jeromq-0.3.5/src/main/java/zmq/ZError.java 0000664 0000000 0000000 00000007156 12551504772 0020366 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 saved = new HashMap();
for (SelectionKey key : selector.keys()) {
if (key.isValid()) {
saved.put(key.channel(), key);
}
}
for (int i = 0; i < count; i++) {
PollItem item = items[i];
if (item == null) {
continue;
}
SelectableChannel ch = item.getChannel(); // mailbox channel if ZMQ socket
SelectionKey key = saved.remove(ch);
if (key != null) {
if (key.interestOps() != item.interestOps()) {
key.interestOps(item.interestOps());
}
key.attach(item);
}
else {
try {
ch.register(selector, item.interestOps(), item);
}
catch (ClosedChannelException e) {
throw new ZError.IOException(e);
}
}
}
if (!saved.isEmpty()) {
for (SelectionKey deprecated : saved.values()) {
deprecated.cancel();
}
}
boolean firstPass = true;
int nevents = 0;
int ready;
while (true) {
// Compute the timeout for the subsequent poll.
long waitMillis;
if (firstPass) {
waitMillis = 0L;
}
else if (timeout < 0L) {
waitMillis = -1L;
}
else {
waitMillis = end - now;
}
// Wait for events.
try {
int rc = 0;
if (waitMillis < 0) {
rc = selector.select(0);
}
else if (waitMillis == 0) {
rc = selector.selectNow();
}
else {
rc = selector.select(waitMillis);
}
for (SelectionKey key : selector.keys()) {
PollItem item = (PollItem) key.attachment();
ready = item.readyOps(key, rc);
if (ready < 0) {
return -1;
}
if (ready > 0) {
nevents++;
}
}
selector.selectedKeys().clear();
}
catch (IOException e) {
throw new ZError.IOException(e);
}
// If timeout is zero, exit immediately whether there are events or not.
if (timeout == 0) {
break;
}
if (nevents > 0) {
break;
}
// At this point we are meant to wait for events but there are none.
// If timeout is infinite we can just loop until we get some events.
if (timeout < 0) {
if (firstPass) {
firstPass = false;
}
continue;
}
// The timeout is finite and there are no events. In the first pass
// we get a timestamp of when the polling have begun. (We assume that
// first pass have taken negligible time). We also compute the time
// when the polling should time out.
if (firstPass) {
now = Clock.nowMS();
end = now + timeout;
if (now == end) {
break;
}
firstPass = false;
continue;
}
// Find out whether timeout have expired.
now = Clock.nowMS();
if (now >= end) {
break;
}
}
return nevents;
}
public static long startStopwatch()
{
return System.nanoTime();
}
public static long stopStopwatch(long watch)
{
return (System.nanoTime() - watch) / 1000;
}
public static int makeVersion(int major, int minor, int patch)
{
return ((major) * 10000 + (minor) * 100 + (patch));
}
public static String strerror(int errno)
{
return "Errno = " + errno;
}
private static final ThreadLocal POLL_SELECTOR = new ThreadLocal();
// GC closes selector handle
private static class PollSelector
{
private Selector selector;
private PollSelector(Selector selector)
{
this.selector = selector;
}
public static Selector open() throws IOException
{
PollSelector polls = POLL_SELECTOR.get();
if (polls == null) {
synchronized (POLL_SELECTOR) {
polls = POLL_SELECTOR.get();
try {
if (polls == null) {
polls = new PollSelector(Selector.open());
POLL_SELECTOR.set(polls);
}
}
catch (IOException e) {
throw new ZError.IOException(e);
}
}
}
return polls.get();
}
public Selector get()
{
assert (selector != null);
assert (selector.isOpen());
return selector;
}
@Override
public void finalize()
{
try {
selector.close();
}
catch (IOException e) {
}
try {
super.finalize();
}
catch (Throwable e) {
}
}
}
}
jeromq-0.3.5/src/main/java/zmq/ZObject.java 0000664 0000000 0000000 00000021177 12551504772 0020502 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 buildZPipe(Context ctx) {
Socket socket1 = ctx.socket(ZMQ.PAIR);
socket1.setLinger(0);
socket1.setHWM(1);
Socket socket2 = ctx.socket(ZMQ.PAIR);
socket2.setLinger(0);
socket2.setHWM(1);
String iface = "inproc://" + new BigInteger(130, rand).toString(32);
socket1.bind(iface);
socket2.connect(iface);
return Arrays.asList(socket1, socket2);
}
}
jeromq-0.3.5/src/test/java/guide/asyncsrv.java 0000664 0000000 0000000 00000013425 12551504772 0021330 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvmap; // Actual key/value table
private String subtree; // Subtree specification, if any
private Server[] server;
private int nbrServers; // 0 to SERVER_MAX
private int state; // Current state
private int curServer; // If active, server 0 or 1
private long sequence; // Last kvmsg processed
private Socket publisher; // Outgoing updates
protected Agent (ZContext ctx, Socket pipe)
{
this.ctx = ctx;
this.pipe = pipe;
kvmap = new HashMap();
subtree = "";
state = STATE_INITIAL;
publisher = ctx.createSocket(ZMQ.PUB);
server = new Server[SERVER_MAX];
}
protected void destroy()
{
for (int serverNbr = 0; serverNbr < nbrServers; serverNbr++)
server[serverNbr].destroy();
}
// .split handling a control message
// Here we handle the different control messages from the frontend;
// SUBTREE, CONNECT, SET, and GET:
private boolean controlMessage()
{
ZMsg msg = ZMsg.recvMsg(pipe);
String command = msg.popString();
if (command == null)
return false; // Interrupted
if (command.equals("SUBTREE")) {
subtree = msg.popString();
}
else
if (command.equals("CONNECT")) {
String address = msg.popString();
String service = msg.popString();
if (nbrServers < SERVER_MAX) {
server [nbrServers++] = new Server(
ctx, address, Integer.parseInt(service), subtree);
// We broadcast updates to all known servers
publisher.connect(String.format("%s:%d",
address, Integer.parseInt(service) + 2));
}
else
System.out.printf("E: too many servers (max. %d)\n", SERVER_MAX);
}
else
// .split set and get commands
// When we set a property, we push the new key-value pair onto
// all our connected servers:
if (command.equals("SET")) {
String key = msg.popString();
String value = msg.popString();
String ttl = msg.popString();
kvmap.put(key, value);
// Send key-value pair on to server
kvmsg kvmsg = new kvmsg(0);
kvmsg.setKey(key);
kvmsg.setUUID();
kvmsg.fmtBody("%s", value);
kvmsg.setProp("ttl", ttl);
kvmsg.send(publisher);
kvmsg.destroy();
}
else
if (command.equals("GET")) {
String key = msg.popString();
String value = kvmap.get(key);
if (value != null)
pipe.send(value);
else
pipe.send("");
}
msg.destroy();
return true;
}
}
private static class CloneAgent implements IAttachedRunnable
{
@Override
public void run(Object[] args, ZContext ctx, Socket pipe)
{
Agent self = new Agent(ctx, pipe);
while (!Thread.currentThread().isInterrupted()) {
PollItem[] pollItems = {
new PollItem(pipe, Poller.POLLIN),
null
};
long pollTimer = -1;
int pollSize = 2;
Server server = self.server[self.curServer];
switch (self.state) {
case STATE_INITIAL:
// In this state we ask the server for a snapshot,
// if we have a server to talk to...
if (self.nbrServers > 0) {
System.out.printf("I: waiting for server at %s:%d...\n",
server.address, server.port);
if (server.requests < 2) {
server.snapshot.sendMore("ICANHAZ?");
server.snapshot.send(self.subtree);
server.requests++;
}
server.expiry = System.currentTimeMillis() + SERVER_TTL;
self.state = STATE_SYNCING;
pollItems[1] = new PollItem(server.snapshot, Poller.POLLIN);
}
else
pollSize = 1;
break;
case STATE_SYNCING:
// In this state we read from snapshot and we expect
// the server to respond, else we fail over.
pollItems[1] = new PollItem(server.snapshot, Poller.POLLIN);
break;
case STATE_ACTIVE:
// In this state we read from subscriber and we expect
// the server to give hugz, else we fail over.
pollItems[1] = new PollItem(server.subscriber, Poller.POLLIN);
break;
}
if (server != null) {
pollTimer = server.expiry - System.currentTimeMillis();
if (pollTimer < 0)
pollTimer = 0;
}
// .split client poll loop
// We're ready to process incoming messages; if nothing at all
// comes from our server within the timeout, that means the
// server is dead:
int rc = ZMQ.poll(pollItems, pollSize, pollTimer);
if (rc == -1)
break; // Context has been shut down
if (pollItems[0].isReadable()) {
if (!self.controlMessage())
break; // Interrupted
}
else
if (pollItems[1].isReadable()) {
kvmsg msg = kvmsg.recv(pollItems[1].getSocket());
if (msg == null)
break; // Interrupted
// Anything from server resets its expiry time
server.expiry = System.currentTimeMillis() + SERVER_TTL;
if (self.state == STATE_SYNCING) {
// Store in snapshot until we're finished
server.requests = 0;
if (msg.getKey().equals("KTHXBAI")) {
self.sequence = msg.getSequence();
self.state = STATE_ACTIVE;
System.out.printf("I: received from %s:%d snapshot=%d\n",
server.address, server.port,
self.sequence);
msg.destroy();
}
}
else
if (self.state == STATE_ACTIVE) {
// Discard out-of-sequence updates, incl. hugz
if (msg.getSequence() > self.sequence) {
self.sequence = msg.getSequence();
System.out.printf("I: received from %s:%d update=%d\n",
server.address, server.port,
self.sequence);
}
else
msg.destroy();
}
}
else {
// Server has died, failover to next
System.out.printf("I: server at %s:%d didn't give hugz\n",
server.address, server.port);
self.curServer = (self.curServer + 1) % self.nbrServers;
self.state = STATE_INITIAL;
}
}
self.destroy();
}
}
}
jeromq-0.3.5/src/test/java/guide/clonecli1.java 0000664 0000000 0000000 00000003355 12551504772 0021332 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonecli1 {
private static Map kvMap = new HashMap();
private static AtomicLong sequence = new AtomicLong();
public void run() {
ZContext ctx = new ZContext();
Socket subscriber = ctx.createSocket(ZMQ.SUB);
subscriber.connect("tcp://localhost:5556");
subscriber.subscribe(ZMQ.SUBSCRIPTION_ALL);
while (true) {
kvsimple kvMsg = kvsimple.recv(subscriber);
if (kvMsg == null)
break;
clonecli1.kvMap.put(kvMsg.getKey(), kvMsg);
System.out.println("receiving " + kvMsg);
sequence.incrementAndGet();
}
ctx.destroy();
}
public static void main(String[] args) {
new clonecli1().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonecli2.java 0000664 0000000 0000000 00000004647 12551504772 0021340 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonecli2 {
private static Map kvMap = new HashMap();
public void run() {
Context ctx = ZMQ.context(1);
Socket snapshot = ctx.socket(ZMQ.DEALER);
snapshot.connect("tcp://localhost:5556");
Socket subscriber = ctx.socket(ZMQ.SUB);
subscriber.connect("tcp://localhost:5557");
subscriber.subscribe(ZMQ.SUBSCRIPTION_ALL);
// get state snapshot
snapshot.send("ICANHAZ?".getBytes(ZMQ.CHARSET), 0);
long sequence = 0;
while (true) {
kvsimple kvMsg = kvsimple.recv(snapshot);
if (kvMsg == null)
break;
sequence = kvMsg.getSequence();
if ("KTHXBAI".equalsIgnoreCase(kvMsg.getKey())) {
System.out.println("Received snapshot = " + kvMsg.getSequence());
break; // done
}
System.out.println("receiving " + kvMsg.getSequence());
clonecli2.kvMap.put(kvMsg.getKey(), kvMsg);
}
// now apply pending updates, discard out-of-getSequence messages
while (true) {
kvsimple kvMsg = kvsimple.recv(subscriber);
if (kvMsg == null)
break;
if (kvMsg.getSequence() > sequence) {
sequence = kvMsg.getSequence();
System.out.println("receiving " + sequence);
clonecli2.kvMap.put(kvMsg.getKey(), kvMsg);
}
}
}
public static void main(String[] args) {
new clonecli2().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonecli3.java 0000664 0000000 0000000 00000006564 12551504772 0021341 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonecli3 {
private static Map kvMap = new HashMap();
public void run() {
ZContext ctx = new ZContext();
Socket snapshot = ctx.createSocket(ZMQ.DEALER);
snapshot.connect("tcp://localhost:5556");
Socket subscriber = ctx.createSocket(ZMQ.SUB);
subscriber.connect("tcp://localhost:5557");
subscriber.subscribe(ZMQ.SUBSCRIPTION_ALL);
Socket push = ctx.createSocket(ZMQ.PUSH);
push.connect("tcp://localhost:5558");
// get state snapshot
long sequence = 0;
snapshot.send("ICANHAZ?".getBytes(ZMQ.CHARSET), 0);
while (true) {
kvsimple kvMsg = kvsimple.recv(snapshot);
if (kvMsg == null)
break; // Interrupted
sequence = kvMsg.getSequence();
if ("KTHXBAI".equalsIgnoreCase(kvMsg.getKey())) {
System.out.println("Received snapshot = " + kvMsg.getSequence());
break; // done
}
System.out.println("receiving " + kvMsg.getSequence());
clonecli3.kvMap.put(kvMsg.getKey(), kvMsg);
}
Poller poller = new ZMQ.Poller(1);
poller.register(subscriber);
Random random = new Random();
// now apply pending updates, discard out-of-getSequence messages
long alarm = System.currentTimeMillis() + 5000;
while (true) {
int rc = poller.poll(Math.max(0, alarm - System.currentTimeMillis()));
if (rc == -1)
break; // Context has been shut down
if (poller.pollin(0)) {
kvsimple kvMsg = kvsimple.recv(subscriber);
if (kvMsg == null)
break; // Interrupted
if (kvMsg.getSequence() > sequence) {
sequence = kvMsg.getSequence();
System.out.println("receiving " + sequence);
clonecli3.kvMap.put(kvMsg.getKey(), kvMsg);
}
}
if (System.currentTimeMillis() >= alarm) {
int key = random.nextInt(10000);
int body = random.nextInt(1000000);
ByteBuffer b = ByteBuffer.allocate(4);
b.asIntBuffer().put(body);
kvsimple kvUpdateMsg = new kvsimple(key + "", 0, b.array());
kvUpdateMsg.send(push);
alarm = System.currentTimeMillis() + 1000;
}
}
ctx.destroy();
}
public static void main(String[] args) {
new clonecli3().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonecli4.java 0000664 0000000 0000000 00000007020 12551504772 0021326 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvMap = new HashMap();
public void run() {
ZContext ctx = new ZContext();
Socket snapshot = ctx.createSocket(ZMQ.DEALER);
snapshot.connect("tcp://localhost:5556");
Socket subscriber = ctx.createSocket(ZMQ.SUB);
subscriber.connect("tcp://localhost:5557");
subscriber.subscribe(SUBTREE.getBytes(ZMQ.CHARSET));
Socket push = ctx.createSocket(ZMQ.PUSH);
push.connect("tcp://localhost:5558");
// get state snapshot
snapshot.sendMore("ICANHAZ?");
snapshot.send(SUBTREE);
long sequence = 0;
while (true) {
kvsimple kvMsg = kvsimple.recv(snapshot);
if (kvMsg == null)
break; // Interrupted
sequence = kvMsg.getSequence();
if ("KTHXBAI".equalsIgnoreCase(kvMsg.getKey())) {
System.out.println("Received snapshot = " + kvMsg.getSequence());
break; // done
}
System.out.println("receiving " + kvMsg.getSequence());
clonecli4.kvMap.put(kvMsg.getKey(), kvMsg);
}
Poller poller = new Poller(1);
poller.register(subscriber);
Random random = new Random();
// now apply pending updates, discard out-of-getSequence messages
long alarm = System.currentTimeMillis() + 5000;
while (true) {
int rc = poller.poll(Math.max(0, alarm - System.currentTimeMillis()));
if (rc == -1)
break; // Context has been shut down
if (poller.pollin(0)) {
kvsimple kvMsg = kvsimple.recv(subscriber);
if (kvMsg == null)
break; // Interrupted
if (kvMsg.getSequence() > sequence) {
sequence = kvMsg.getSequence();
System.out.println("receiving " + sequence);
clonecli4.kvMap.put(kvMsg.getKey(), kvMsg);
}
}
if (System.currentTimeMillis() >= alarm) {
String key = String.format("%s%d", SUBTREE, random.nextInt(10000));
int body = random.nextInt(1000000);
ByteBuffer b = ByteBuffer.allocate(4);
b.asIntBuffer().put(body);
kvsimple kvUpdateMsg = new kvsimple(key, 0, b.array());
kvUpdateMsg.send(push);
alarm = System.currentTimeMillis() + 1000;
}
}
ctx.destroy();
}
public static void main(String[] args) {
new clonecli4().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonecli5.java 0000664 0000000 0000000 00000007026 12551504772 0021335 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvMap = new HashMap();
// get state snapshot
snapshot.sendMore("ICANHAZ?");
snapshot.send(SUBTREE);
long sequence = 0;
while (true) {
kvmsg kvMsg = kvmsg.recv(snapshot);
if (kvMsg == null)
break; // Interrupted
sequence = kvMsg.getSequence();
if ("KTHXBAI".equalsIgnoreCase(kvMsg.getKey())) {
System.out.println("Received snapshot = " + kvMsg.getSequence());
kvMsg.destroy();
break; // done
}
System.out.println("receiving " + kvMsg.getSequence());
kvMsg.store(kvMap);
}
Poller poller = new Poller(1);
poller.register(subscriber);
Random random = new Random();
// now apply pending updates, discard out-of-getSequence messages
long alarm = System.currentTimeMillis() + 5000;
while (true) {
int rc = poller.poll(Math.max(0, alarm - System.currentTimeMillis()));
if (rc == -1)
break; // Context has been shut down
if (poller.pollin(0)) {
kvmsg kvMsg = kvmsg.recv(subscriber);
if (kvMsg == null)
break; // Interrupted
if (kvMsg.getSequence() > sequence) {
sequence = kvMsg.getSequence();
System.out.println("receiving " + sequence);
kvMsg.store(kvMap);
} else
kvMsg.destroy();
}
if (System.currentTimeMillis() >= alarm) {
kvmsg kvMsg = new kvmsg(0);
kvMsg.fmtKey("%s%d", SUBTREE, random.nextInt(10000));
kvMsg.fmtBody("%d", random.nextInt(1000000));
kvMsg.setProp("ttl", "%d", random.nextInt(30));
kvMsg.send(publisher);
kvMsg.destroy();
alarm = System.currentTimeMillis() + 1000;
}
}
ctx.destroy();
}
public static void main(String[] args) {
new clonecli5().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonecli6.java 0000664 0000000 0000000 00000003734 12551504772 0021340 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonesrv1 {
private static AtomicLong sequence = new AtomicLong();
public void run() {
Context ctx = ZMQ.context(1);
Socket publisher = ctx.socket(ZMQ.PUB);
publisher.bind("tcp://*:5556");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
Random random = new Random();
while (true) {
long currentSequenceNumber = sequence.incrementAndGet();
int key = random.nextInt(10000);
int body = random.nextInt(1000000);
ByteBuffer b = ByteBuffer.allocate(4);
b.asIntBuffer().put(body);
kvsimple kvMsg = new kvsimple(key + "", currentSequenceNumber,
b.array());
kvMsg.send(publisher);
System.out.println("sending " + kvMsg);
}
}
public static void main(String[] args) {
new clonesrv1().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonesrv2.java 0000664 0000000 0000000 00000010775 12551504772 0021402 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonesrv2 {
public void run() {
ZContext ctx = new ZContext();
Socket publisher = ctx.createSocket(ZMQ.PUB);
publisher.bind("tcp://*:5557");
Socket updates = ZThread.fork(ctx, new StateManager());
Random random = new Random();
long sequence = 0;
while (!Thread.currentThread().isInterrupted()) {
long currentSequenceNumber = ++sequence;
int key = random.nextInt(10000);
int body = random.nextInt(1000000);
ByteBuffer b = ByteBuffer.allocate(4);
b.asIntBuffer().put(body);
kvsimple kvMsg = new kvsimple(key + "", currentSequenceNumber, b.array());
kvMsg.send(publisher);
kvMsg.send(updates); // send a message to State Manager thead.
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
System.out.printf(" Interrupted\n%d messages out\n", sequence);
ctx.destroy();
}
public static class StateManager implements IAttachedRunnable {
private static Map kvMap = new LinkedHashMap();
@Override
public void run(Object[] args, ZContext ctx, Socket pipe) {
pipe.send("READY"); // optional
Socket snapshot = ctx.createSocket(ZMQ.ROUTER);
snapshot.bind("tcp://*:5556");
Poller poller = new ZMQ.Poller(2);
poller.register(pipe, ZMQ.Poller.POLLIN);
poller.register(snapshot, ZMQ.Poller.POLLIN);
long stateSequence = 0;
while (!Thread.currentThread().isInterrupted()) {
if (poller.poll() < 0)
break; // Context has been shut down
// apply state updates from main thread
if (poller.pollin(0)) {
kvsimple kvMsg = kvsimple.recv(pipe);
if (kvMsg == null)
break;
StateManager.kvMap.put(kvMsg.getKey(), kvMsg);
stateSequence = kvMsg.getSequence();
}
// execute state snapshot request
if (poller.pollin(1)) {
byte[] identity = snapshot.recv(0);
if (identity == null)
break;
String request = new String(snapshot.recv(0), ZMQ.CHARSET);
if (!request.equals("ICANHAZ?")) {
System.out.println("E: bad request, aborting");
break;
}
Iterator> iter = kvMap.entrySet().iterator();
while (iter.hasNext()) {
Entry entry = iter.next();
kvsimple msg = entry.getValue();
System.out.println("Sending message " + entry.getValue().getSequence());
this.sendMessage(msg, identity, snapshot);
}
// now send end message with getSequence number
System.out.println("Sending state snapshot = " + stateSequence);
snapshot.send(identity, ZMQ.SNDMORE);
kvsimple message = new kvsimple("KTHXBAI", stateSequence, ZMQ.MESSAGE_SEPARATOR);
message.send(snapshot);
}
}
}
private void sendMessage(kvsimple msg, byte[] identity, Socket snapshot) {
snapshot.send(identity, ZMQ.SNDMORE);
msg.send(snapshot);
}
}
public static void main(String[] args) {
new clonesrv2().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonesrv3.java 0000664 0000000 0000000 00000007475 12551504772 0021406 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class clonesrv3 {
private static Map kvMap = new LinkedHashMap();
public void run() {
ZContext ctx = new ZContext();
Socket snapshot = ctx.createSocket(ZMQ.ROUTER);
snapshot.bind("tcp://*:5556");
Socket publisher = ctx.createSocket(ZMQ.PUB);
publisher.bind("tcp://*:5557");
Socket collector = ctx.createSocket(ZMQ.PULL);
collector.bind("tcp://*:5558");
Poller poller = new Poller(2);
poller.register(collector, Poller.POLLIN);
poller.register(snapshot, Poller.POLLIN);
long sequence = 0;
while (!Thread.currentThread().isInterrupted()) {
if (poller.poll(1000) < 0)
break; // Context has been shut down
// apply state updates from main thread
if (poller.pollin(0)) {
kvsimple kvMsg = kvsimple.recv(collector);
if (kvMsg == null) // Interrupted
break;
kvMsg.setSequence(++sequence);
kvMsg.send(publisher);
clonesrv3.kvMap.put(kvMsg.getKey(), kvMsg);
System.out.printf("I: publishing update %5d\n", sequence);
}
// execute state snapshot request
if (poller.pollin(1)) {
byte[] identity = snapshot.recv(0);
if (identity == null)
break; // Interrupted
String request = snapshot.recvStr();
if (!request.equals("ICANHAZ?")) {
System.out.println("E: bad request, aborting");
break;
}
Iterator> iter = kvMap.entrySet().iterator();
while (iter.hasNext()) {
Entry entry = iter.next();
kvsimple msg = entry.getValue();
System.out.println("Sending message " + entry.getValue().getSequence());
this.sendMessage(msg, identity, snapshot);
}
// now send end message with getSequence number
System.out.println("Sending state snapshot = " + sequence);
snapshot.send(identity, ZMQ.SNDMORE);
kvsimple message = new kvsimple("KTHXBAI", sequence, ZMQ.SUBSCRIPTION_ALL);
message.send(snapshot);
}
}
System.out.printf (" Interrupted\n%d messages handled\n", sequence);
ctx.destroy();
}
private void sendMessage(kvsimple msg, byte[] identity, Socket snapshot) {
snapshot.send(identity, ZMQ.SNDMORE);
msg.send(snapshot);
}
public static void main(String[] args) {
new clonesrv3().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonesrv4.java 0000664 0000000 0000000 00000007731 12551504772 0021402 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvMap = new LinkedHashMap();
public void run() {
ZContext ctx = new ZContext();
Socket snapshot = ctx.createSocket(ZMQ.ROUTER);
snapshot.bind("tcp://*:5556");
Socket publisher = ctx.createSocket(ZMQ.PUB);
publisher.bind("tcp://*:5557");
Socket collector = ctx.createSocket(ZMQ.PULL);
collector.bind("tcp://*:5558");
Poller poller = new Poller(2);
poller.register(collector, Poller.POLLIN);
poller.register(snapshot, Poller.POLLIN);
long sequence = 0;
while (!Thread.currentThread().isInterrupted()) {
if (poller.poll(1000) < 0)
break; // Context has been shut down
// apply state updates from main thread
if (poller.pollin(0)) {
kvsimple kvMsg = kvsimple.recv(collector);
if (kvMsg == null) // Interrupted
break;
kvMsg.setSequence(++sequence);
kvMsg.send(publisher);
clonesrv4.kvMap.put(kvMsg.getKey(), kvMsg);
System.out.printf("I: publishing update %5d\n", sequence);
}
// execute state snapshot request
if (poller.pollin(1)) {
byte[] identity = snapshot.recv(0);
if (identity == null)
break; // Interrupted
// .until
// Request is in second frame of message
String request = snapshot.recvStr();
if (!request.equals("ICANHAZ?")) {
System.out.println("E: bad request, aborting");
break;
}
String subtree = snapshot.recvStr();
Iterator> iter = kvMap.entrySet().iterator();
while (iter.hasNext()) {
Entry entry = iter.next();
kvsimple msg = entry.getValue();
System.out.println("Sending message " + entry.getValue().getSequence());
this.sendMessage(msg, identity, subtree, snapshot);
}
// now send end message with getSequence number
System.out.println("Sending state snapshot = " + sequence);
snapshot.send(identity, ZMQ.SNDMORE);
kvsimple message = new kvsimple("KTHXBAI", sequence, ZMQ.SUBSCRIPTION_ALL);
message.send(snapshot);
}
}
System.out.printf (" Interrupted\n%d messages handled\n", sequence);
ctx.destroy();
}
private void sendMessage(kvsimple msg, byte[] identity, String subtree, Socket snapshot) {
snapshot.send(identity, ZMQ.SNDMORE);
snapshot.send(subtree, ZMQ.SNDMORE);
msg.send(snapshot);
}
public static void main(String[] args) {
new clonesrv4().run();
}
}
jeromq-0.3.5/src/test/java/guide/clonesrv5.java 0000664 0000000 0000000 00000015415 12551504772 0021401 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvmap; // Key-value store
private ZLoop loop; // zloop reactor
private int port; // Main port we're working on
private long sequence; // How many updates we're at
private Socket snapshot; // Handle snapshot requests
private Socket publisher; // Publish updates to clients
private Socket collector; // Collect updates from clients
// .split snapshot handler
// This is the reactor handler for the snapshot socket; it accepts
// just the ICANHAZ? request and replies with a state snapshot ending
// with a KTHXBAI message:
private static class Snapshots implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv5 srv = (clonesrv5) arg;
Socket socket = item.getSocket();
byte[] identity = socket.recv();
if (identity != null) {
// Request is in second frame of message
String request = socket.recvStr();
String subtree = null;
if (request.equals("ICANHAZ?")) {
subtree = socket.recvStr();
}
else
System.out.printf("E: bad request, aborting\n");
if (subtree != null) {
// Send state socket to client
for (Entry entry: srv.kvmap.entrySet()) {
sendSingle(entry.getValue(), identity, subtree, socket);
}
// Now send END message with getSequence number
System.out.printf("I: sending shapshot=%d\n", srv.sequence);
socket.send(identity, ZMQ.SNDMORE);
kvmsg kvmsg = new kvmsg(srv.sequence);
kvmsg.setKey("KTHXBAI");
kvmsg.setBody(subtree.getBytes(ZMQ.CHARSET));
kvmsg.send(socket);
kvmsg.destroy();
}
}
return 0;
}
}
// .split collect updates
// We store each update with a new getSequence number, and if necessary, a
// time-to-live. We publish updates immediately on our publisher socket:
private static class Collector implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv5 srv = (clonesrv5) arg;
Socket socket = item.getSocket();
kvmsg msg = kvmsg.recv(socket);
if (msg != null) {
msg.setSequence(++srv.sequence);
msg.send(srv.publisher);
int ttl = Integer.parseInt(msg.getProp("ttl"));
if (ttl > 0)
msg.setProp("ttl",
"%d", System.currentTimeMillis() + ttl * 1000);
msg.store(srv.kvmap);
System.out.printf("I: publishing update=%d\n", srv.sequence);
}
return 0;
}
}
private static class FlushTTL implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv5 srv = (clonesrv5) arg;
if (srv.kvmap != null) {
for (kvmsg msg: new ArrayList(srv.kvmap.values())) {
srv.flushSingle(msg);
}
}
return 0;
}
}
public clonesrv5 ()
{
port = 5556;
ctx = new ZContext();
kvmap = new HashMap();
loop = new ZLoop();
loop.verbose(false);
// Set up our clone server sockets
snapshot = ctx.createSocket(ZMQ.ROUTER);
snapshot.bind(String.format("tcp://*:%d", port));
publisher = ctx.createSocket(ZMQ.PUB);
publisher.bind(String.format("tcp://*:%d", port + 1));
collector = ctx.createSocket(ZMQ.PULL);
collector.bind(String.format("tcp://*:%d", port + 2));
}
public void run()
{
// Register our handlers with reactor
PollItem poller = new PollItem(snapshot, ZMQ.Poller.POLLIN);
loop.addPoller(poller, new Snapshots(), this);
poller = new PollItem(collector, ZMQ.Poller.POLLIN);
loop.addPoller(poller, new Collector(), this);
loop.addTimer(1000, 0, new FlushTTL(), this);
loop.start();
loop.destroy();
ctx.destroy();
}
// We call this function for each getKey-value pair in our hash table
private static void sendSingle(kvmsg msg, byte[] identity, String subtree, Socket socket)
{
if (msg.getKey().startsWith(subtree)) {
socket.send (identity, // Choose recipient
ZMQ.SNDMORE);
msg.send(socket);
}
}
// .split flush ephemeral values
// At regular intervals, we flush ephemeral values that have expired. This
// could be slow on very large data sets:
// If getKey-value pair has expired, delete it and publish the
// fact to listening clients.
private void flushSingle(kvmsg msg)
{
long ttl = Long.parseLong(msg.getProp("ttl"));
if (ttl > 0 && System.currentTimeMillis() >= ttl) {
msg.setSequence(++sequence);
msg.setBody(ZMQ.MESSAGE_SEPARATOR);
msg.send(publisher);
msg.store(kvmap);
System.out.printf("I: publishing delete=%d\n", sequence);
}
}
public static void main(String[] args)
{
clonesrv5 srv = new clonesrv5();
srv.run();
}
}
jeromq-0.3.5/src/test/java/guide/clonesrv6.java 0000664 0000000 0000000 00000035714 12551504772 0021406 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 kvmap; // Key-value store
private bstar bStar; // Bstar reactor core
private long sequence; // How many updates we're at
private int port; // Main port we're working on
private int peer; // Main port of our peer
private Socket publisher; // Publish updates and hugz
private Socket collector; // Collect updates from clients
private Socket subscriber; // Get updates from peer
private List pending; // Pending updates from clients
private boolean primary; // TRUE if we're primary
private boolean active; // TRUE if we're active
private boolean passive; // TRUE if we're passive
private static class Snapshots implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
Socket socket = item.getSocket();
byte[] identity = socket.recv();
if (identity != null) {
// Request is in second frame of message
String request = socket.recvStr();
String subtree = null;
if (request.equals("ICANHAZ?")) {
subtree = socket.recvStr();
}
else
System.out.printf("E: bad request, aborting\n");
if (subtree != null) {
// Send state socket to client
for (Entry entry: srv.kvmap.entrySet()) {
sendSingle(entry.getValue(), identity, subtree, socket);
}
// Now send END message with getSequence number
System.out.printf("I: sending shapshot=%d\n", srv.sequence);
socket.send(identity, ZMQ.SNDMORE);
kvmsg kvmsg = new kvmsg(srv.sequence);
kvmsg.setKey("KTHXBAI");
kvmsg.setBody(subtree.getBytes(ZMQ.CHARSET));
kvmsg.send(socket);
kvmsg.destroy();
}
}
return 0;
}
}
private static class Collector implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
Socket socket = item.getSocket();
kvmsg msg = kvmsg.recv(socket);
if (msg != null) {
if(srv.active){
msg.setSequence(++srv.sequence);
msg.send(srv.publisher);
int ttl = Integer.parseInt(msg.getProp("ttl"));
if (ttl > 0)
msg.setProp("ttl",
"%d", System.currentTimeMillis() + ttl * 1000);
msg.store(srv.kvmap);
System.out.printf("I: publishing update=%d\n", srv.sequence);
} else {
// If we already got message from active, drop it, else
// hold on pending list
if (srv.wasPending(msg))
msg.destroy();
else
srv.pending.add(msg);
}
}
return 0;
}
}
// .split heartbeating
// We send a HUGZ message once a second to all subscribers so that they
// can detect if our server dies. They'll then switch over to the backup
// server, which will become active:
private static class SendHugz implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
kvmsg msg = new kvmsg(srv.sequence);
msg.setKey("HUGZ");
msg.setBody(ZMQ.MESSAGE_SEPARATOR);
msg.send(srv.publisher);
msg.destroy();
return 0;
}
}
private static class FlushTTL implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
if (srv.kvmap != null) {
for (kvmsg msg: new ArrayList(srv.kvmap.values())) {
srv.flushSingle(msg);
}
}
return 0;
}
}
// .split handling state changes
// When we switch from passive to active, we apply our pending list so that
// our kvmap is up-to-date. When we switch to passive, we wipe our kvmap
// and grab a new snapshot from the active server:
private static class NewActive implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
srv.active = true;
srv.passive = false;
// Stop subscribing to updates
PollItem poller = new PollItem(srv.subscriber, ZMQ.Poller.POLLIN);
srv.bStar.zloop().removePoller(poller);
// Apply pending list to own hash table
for (kvmsg msg: srv.pending) {
msg.setSequence(++srv.sequence);
msg.send(srv.publisher);
msg.store(srv.kvmap);
System.out.printf("I: publishing pending=%d\n", srv.sequence);
}
return 0;
}
}
private static class NewPassive implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
if (srv.kvmap != null) {
for (kvmsg msg: srv.kvmap.values())
msg.destroy();
}
srv.active = false;
srv.passive = true;
// Start subscribing to updates
PollItem poller = new PollItem(srv.subscriber, ZMQ.Poller.POLLIN);
srv.bStar.zloop().addPoller(poller, new Subscriber(), srv);
return 0;
}
}
// .split subscriber handler
// When we get an update, we create a new kvmap if necessary, and then
// add our update to our kvmap. We're always passive in this case:
private static class Subscriber implements IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg)
{
clonesrv6 srv = (clonesrv6) arg;
Socket socket = item.getSocket();
// Get state snapshot if necessary
if (srv.kvmap == null) {
srv.kvmap = new HashMap();
Socket snapshot = srv.ctx.createSocket(ZMQ.DEALER);
snapshot.connect(String.format("tcp://localhost:%d", srv.peer));
System.out.printf("I: asking for snapshot from: tcp://localhost:%d\n",
srv.peer);
snapshot.sendMore("ICANHAZ?");
snapshot.send(""); // blank subtree to get all
while (true) {
kvmsg msg = kvmsg.recv(snapshot);
if (msg == null)
break; // Interrupted
if (msg.getKey().equals("KTHXBAI")) {
srv.sequence = msg.getSequence();
msg.destroy();
break; // Done
}
msg.store(srv.kvmap);
}
System.out.printf("I: received snapshot=%d\n",srv.sequence);
srv.ctx.destroySocket(snapshot);
}
// Find and remove update off pending list
kvmsg msg = kvmsg.recv(item.getSocket());
if (msg == null)
return 0;
if (!msg.getKey().equals("HUGZ")) {
if (!srv.wasPending(msg)) {
// If active update came before client update, flip it
// around, store active update (with sequence) on pending
// list and use to clear client update when it comes later
srv.pending.add(msg.dup());
}
// If update is more recent than our kvmap, apply it
if (msg.getSequence() > srv.sequence) {
srv.sequence = msg.getSequence();
msg.store(srv.kvmap);
System.out.printf("I: received update=%d\n",srv.sequence);
}
}
msg.destroy();
return 0;
}
}
public clonesrv6(boolean primary)
{
if (primary) {
bStar = new bstar(true, "tcp://*:5003",
"tcp://localhost:5004");
bStar.voter("tcp://*:5556",
ZMQ.ROUTER, new Snapshots(), this);
port = 5556;
peer = 5566;
this.primary = true;
} else {
bStar = new bstar(false, "tcp://*:5004",
"tcp://localhost:5003");
bStar.voter("tcp://*:5566",
ZMQ.ROUTER, new Snapshots(), this);
port = 5566;
peer = 5556;
this.primary = false;
}
// Primary server will become first active
if (primary)
kvmap = new HashMap();
ctx = new ZContext();
pending = new ArrayList();
bStar.setVerbose(true);
// Set up our clone server sockets
publisher = ctx.createSocket(ZMQ.PUB);
collector = ctx.createSocket(ZMQ.SUB);
collector.subscribe(ZMQ.SUBSCRIPTION_ALL);
publisher.bind(String.format("tcp://*:%d", port + 1));
collector.bind(String.format("tcp://*:%d", port+2));
// Set up our own clone client interface to peer
subscriber = ctx.createSocket(ZMQ.SUB);
subscriber.subscribe(ZMQ.SUBSCRIPTION_ALL);
subscriber.connect(String.format("tcp://localhost:%d", peer + 1));
}
// .split main task body
// After we've setup our sockets, we register our binary star
// event handlers, and then start the bstar reactor. This finishes
// when the user presses Ctrl-C or when the process receives a SIGINT
// interrupt:
public void run()
{
// Register state change handlers
bStar.newActive(new NewActive(), this);
bStar.newPassive(new NewPassive(), this);
// Register our other handlers with the bstar reactor
PollItem poller = new PollItem(collector, ZMQ.Poller.POLLIN);
bStar.zloop().addPoller(poller, new Collector(), this);
bStar.zloop().addTimer(1000, 0, new FlushTTL(), this);
bStar.zloop().addTimer(1000, 0, new SendHugz(), this);
// Start the bstar reactor
bStar.start();
// Interrupted, so shut down
for (kvmsg value: pending)
value.destroy();
bStar.destroy();
for (kvmsg value: kvmap.values())
value.destroy();
ctx.destroy();
}
// Send one state snapshot key-value pair to a socket
// Hash item data is our kvmsg object, ready to send
private static void sendSingle(kvmsg msg, byte[] identity, String subtree, Socket socket)
{
if (msg.getKey().startsWith(subtree)) {
socket.send (identity, // Choose recipient
ZMQ.SNDMORE);
msg.send(socket);
}
}
// The collector is more complex than in the clonesrv5 example because the
// way it processes updates depends on whether we're active or passive.
// The active applies them immediately to its kvmap, whereas the passive
// queues them as pending:
// If message was already on pending list, remove it and return TRUE,
// else return FALSE.
boolean wasPending (kvmsg msg)
{
Iterator it = pending.iterator();
while (it.hasNext()) {
if(java.util.Arrays.equals(msg.UUID(), it.next().UUID())){
it.remove();
return true;
}
}
return false;
}
// We purge ephemeral values using exactly the same code as in
// the previous clonesrv5 example.
// .skip
// If key-value pair has expired, delete it and publish the
// fact to listening clients.
private void flushSingle(kvmsg msg)
{
long ttl = Long.parseLong(msg.getProp("ttl"));
if (ttl > 0 && System.currentTimeMillis() >= ttl) {
msg.setSequence(++sequence);
msg.setBody(ZMQ.MESSAGE_SEPARATOR);
msg.send(publisher);
msg.store(kvmap);
System.out.printf("I: publishing delete=%d\n", sequence);
}
}
// .split main task setup
// The main task parses the command line to decide whether to start
// as a primary or backup server. We're using the Binary Star pattern
// for reliability. This interconnects the two servers so they can
// agree on which one is primary and which one is backup. To allow the
// two servers to run on the same box, we use different ports for
// primary and backup. Ports 5003/5004 are used to interconnect the
// servers. Ports 5556/5566 are used to receive voting events (snapshot
// requests in the clone pattern). Ports 5557/5567 are used by the
// publisher, and ports 5558/5568 are used by the collector:
public static void main(String[] args)
{
clonesrv6 srv = null;
if (args.length == 1 && "-p".equals(args[0])) {
srv = new clonesrv6(true);
} else if (args.length == 1 && "-b".equals(args[0])) {
srv = new clonesrv6(false);
} else {
System.out.printf("Usage: clonesrv4 { -p | -b }\n");
System.exit(0);
}
srv.run();
}
}
jeromq-0.3.5/src/test/java/guide/espresso.java 0000664 0000000 0000000 00000010546 12551504772 0021324 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 servers; // Servers we've connected to
private List actives; // Servers we know are alive
private int sequence; // Number of requests ever sent
private ZMsg request; // Current request if any
private ZMsg reply; // Current reply if any
private long expires; // Timeout for request/reply
protected Agent(ZContext ctx, Socket pipe)
{
this.ctx = ctx;
this.pipe = pipe;
router = ctx.createSocket(ZMQ.ROUTER);
servers = new HashMap();
actives = new ArrayList();
}
protected void destroy()
{
for(Server server: servers.values())
server.destroy();
}
// .split control messages
// This method processes one message from our frontend class
// (it's going to be CONNECT or REQUEST):
// Callback when we remove server from agent 'servers' hash table
private void controlMessage()
{
ZMsg msg = ZMsg.recvMsg(pipe);
String command = msg.popString();
if (command.equals("CONNECT")) {
String endpoint = msg.popString();
System.out.printf("I: connecting to %s...\n", endpoint);
router.connect(endpoint);
Server server = new Server(endpoint);
servers.put(endpoint, server);
actives.add(server);
server.pingAt = System.currentTimeMillis() + PING_INTERVAL;
server.expires = System.currentTimeMillis() + SERVER_TTL;
}
else
if (command.equals("REQUEST")) {
assert (request == null); // Strict request-reply cycle
// Prefix request with getSequence number and empty envelope
String sequenceText = String.format("%d", ++sequence);
msg.push(sequenceText);
// Take ownership of request message
request = msg;
msg = null;
// Request expires after global timeout
expires = System.currentTimeMillis() + GLOBAL_TIMEOUT;
}
if (msg != null)
msg.destroy();
}
// .split router messages
// This method processes one message from a connected
// server:
private void routerMessage()
{
ZMsg reply = ZMsg.recvMsg(router);
// Frame 0 is server that replied
String endpoint = reply.popString();
Server server = servers.get(endpoint);
assert (server != null);
if (!server.alive) {
actives.add(server);
server.alive = true;
}
server.pingAt = System.currentTimeMillis() + PING_INTERVAL;
server.expires = System.currentTimeMillis() + SERVER_TTL;
// Frame 1 may be getSequence number for reply
String sequenceStr = reply.popString();
if (Integer.parseInt(sequenceStr) == sequence) {
reply.push("OK");
reply.send(pipe);
request.destroy();
request = null;
}
else
reply.destroy();
}
}
// .split backend agent implementation
// Finally, here's the agent task itself, which polls its two sockets
// and processes incoming messages:
static private class FreelanceAgent implements IAttachedRunnable
{
@Override
public void run(Object[] args, ZContext ctx, Socket pipe)
{
Agent agent = new Agent(ctx, pipe);
PollItem[] items = {
new PollItem(agent.pipe, ZMQ.Poller.POLLIN),
new PollItem(agent.router, ZMQ.Poller.POLLIN)
};
while (!Thread.currentThread().isInterrupted()) {
// Calculate tickless timer, up to 1 hour
long tickless = System.currentTimeMillis() + 1000 * 3600;
if (agent.request != null
&& tickless > agent.expires)
tickless = agent.expires;
for (Server server: agent.servers.values()) {
long newTickless = server.tickless(tickless);
if (newTickless > 0)
tickless = newTickless;
}
int rc = ZMQ.poll(items,
(tickless - System.currentTimeMillis()));
if (rc == -1)
break; // Context has been shut down
if (items[0].isReadable())
agent.controlMessage();
if (items[1].isReadable())
agent.routerMessage();
// If we're processing a request, dispatch to next server
if (agent.request != null) {
if (System.currentTimeMillis() >= agent.expires) {
// Request expired, kill it
agent.pipe.send("FAILED");
agent.request.destroy();
agent.request = null;
}
else {
// Find server to talk to, remove any expired ones
while (!agent.actives.isEmpty()) {
Server server = agent.actives.get(0);
if (System.currentTimeMillis() >= server.expires) {
agent.actives.remove(0);
server.alive = false;
}
else {
ZMsg request = agent.request.duplicate();
request.push(server.endpoint);
request.send(agent.router);
break;
}
}
}
}
// Disconnect and delete any expired servers
// Send heartbeats to idle servers if needed
for (Server server: agent.servers.values())
server.ping(agent.router);
}
agent.destroy();
}
}
}
jeromq-0.3.5/src/test/java/guide/flclient1.java 0000664 0000000 0000000 00000006724 12551504772 0021345 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 ...\n");
else
if (endpoints == 1) {
// For one endpoint, we retry N times
int retries;
for (retries = 0; retries < MAX_RETRIES; retries++) {
String endpoint = argv [0];
reply = tryRequest(ctx, endpoint, request);
if (reply != null)
break; // Successful
System.out.printf("W: no response from %s, retrying...\n", endpoint);
}
}
else {
// For multiple endpoints, try each at most once
int endpointNbr;
for (endpointNbr = 0; endpointNbr < endpoints; endpointNbr++) {
String endpoint = argv[endpointNbr];
reply = tryRequest (ctx, endpoint, request);
if (reply != null)
break; // Successful
System.out.printf ("W: no response from %s\n", endpoint);
}
}
if (reply != null) {
System.out.printf ("Service is running OK\n");
reply.destroy();
}
request.destroy();;
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/flclient2.java 0000664 0000000 0000000 00000010553 12551504772 0021341 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 ...\n");
System.exit(0);
}
// Create new freelance client object
flclient2 client = new flclient2();
// Connect to each endpoint
int argn;
for (argn = 0; argn < argv.length; argn++)
client.connect(argv[argn]);
// Send a bunch of name resolution 'requests', measure time
int requests = 10000;
long start = System.currentTimeMillis();
while (requests-- > 0) {
ZMsg request = new ZMsg();
request.add("random name");
ZMsg reply = client.request(request);
if (reply == null) {
System.out.printf("E: name service not available, aborting\n");
break;
}
reply.destroy();
}
System.out.printf ("Average round trip cost: %d usec\n",
(int) (System.currentTimeMillis() - start) / 10);
client.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/flclient3.java 0000664 0000000 0000000 00000003746 12551504772 0021350 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 \n");
System.exit(0);
}
ZContext ctx = new ZContext();
Socket server = ctx.createSocket(ZMQ.REP);
server.bind(args[0]);
System.out.printf ("I: echo service is ready at %s\n", args[0]);
while (true) {
ZMsg msg = ZMsg.recvMsg(server);
if (msg == null)
break; // Interrupted
msg.send(server);
}
if (Thread.currentThread().isInterrupted())
System.out.printf ("W: interrupted\n");
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/flserver2.java 0000664 0000000 0000000 00000003734 12551504772 0021374 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 \n");
System.exit(0);
}
ZContext ctx = new ZContext();
Socket server = ctx.createSocket(ZMQ.REP);
server.bind(args[0]);
System.out.printf ("I: echo service is ready at %s\n", args[0]);
while (true) {
ZMsg request = ZMsg.recvMsg(server);
if (request == null)
break; // Interrupted
// Fail nastily if run against wrong client
assert (request.size() == 2);
ZFrame identity = request.pop();
request.destroy();
ZMsg reply = new ZMsg();
reply.add(identity);
reply.add("OK");
reply.send(server);
}
if (Thread.currentThread().isInterrupted())
System.out.printf ("W: interrupted\n");
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/flserver3.java 0000664 0000000 0000000 00000005101 12551504772 0021363 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 o: props.entrySet()) {
String prop = o.getKey().toString() + "=" + o.getValue().toString() + "\n";
msg.put(prop.getBytes(ZMQ.CHARSET));
}
present[FRAME_PROPS] = true;
frame[FRAME_PROPS] = msg.array();
}
private void decodeProps()
{
byte[] msg = frame[FRAME_PROPS];
props_size = msg.length;
props.clear();
if (msg.length == 0)
return;
System.out.println("" + msg.length + " :" + new String(msg, ZMQ.CHARSET));
for (String prop: new String(msg, ZMQ.CHARSET).split("\n")) {
String[] split = prop.split("=");
props.setProperty(split[0], split[1]);
}
}
// .split constructor and destructor
// Here are the constructor and destructor for the class:
// Constructor, takes a getSequence number for the new kvmsg instance:
public kvmsg(long sequence)
{
props = new Properties();
setSequence(sequence);
}
public void destroy()
{
}
// .split recv method
// This method reads a getKey-value message from the socket and returns a
// new {{kvmsg}} instance:
public static kvmsg recv(Socket socket)
{
// This method is almost unchanged from kvsimple
// .skip
assert (socket != null);
kvmsg self = new kvmsg(0);
// Read all frames off the wire, reject if bogus
int frameNbr;
for (frameNbr = 0; frameNbr < KVMSG_FRAMES; frameNbr++) {
//zmq_msg_init (&self->frame [frameNbr]);
self.present[frameNbr] = true;
if ((self.frame[frameNbr] = socket.recv(0)) == null) {
self.destroy();
break;
}
// Verify multipart framing
boolean rcvmore = (frameNbr < KVMSG_FRAMES - 1)? true: false;
if (socket.hasReceiveMore() != rcvmore) {
self.destroy();
break;
}
}
// .until
self.decodeProps();
return self;
}
// Send getKey-value message to socket; any empty frames are sent as such.
public void send(Socket socket)
{
assert (socket != null);
encodeProps();
// The rest of the method is unchanged from kvsimple
// .skip
int frameNbr;
for (frameNbr = 0; frameNbr < KVMSG_FRAMES; frameNbr++) {
byte[] copy = ZMQ.MESSAGE_SEPARATOR;
if (present[frameNbr])
copy = frame[frameNbr];
socket.send(copy, (frameNbr < KVMSG_FRAMES - 1)? ZMQ.SNDMORE: 0);
}
}
// .until
// .split dup method
// This method duplicates a {{kvmsg}} instance, returns the new instance:
public kvmsg dup()
{
kvmsg kvmsg = new kvmsg(0);
int frameNbr;
for (frameNbr = 0; frameNbr < KVMSG_FRAMES; frameNbr++) {
if (present[frameNbr]) {
kvmsg.frame[frameNbr] = new byte[frame[frameNbr].length];
System.arraycopy(frame[frameNbr], 0,
kvmsg.frame[frameNbr], 0, frame[frameNbr].length);
kvmsg.present[frameNbr] = true;
}
}
kvmsg.props_size = props_size;
kvmsg.props.putAll(props);
return kvmsg;
}
// The getKey, getSequence, body, and size methods are the same as in kvsimple.
// .skip
// Return getKey from last read message, if any, else NULL
public String getKey()
{
if (present[FRAME_KEY]) {
if (key == null) {
int size = frame[FRAME_KEY].length;
if (size > KVMSG_KEY_MAX)
size = KVMSG_KEY_MAX;
byte[] buf = new byte[size];
System.arraycopy(frame[FRAME_KEY], 0, buf, 0, size);
key = new String(buf, ZMQ.CHARSET);
}
return key;
}
else
return null;
}
// Set message getKey as provided
public void setKey(String key)
{
byte[] msg = new byte[key.length()];
System.arraycopy(key.getBytes(ZMQ.CHARSET), 0, msg, 0, key.length());
frame[FRAME_KEY] = msg;
present[FRAME_KEY] = true;
}
// Set message getKey using printf format
public void fmtKey(String fmt, Object ... args)
{
setKey(String.format(fmt, args));
}
// Return getSequence nbr from last read message, if any
public long getSequence()
{
if (present[FRAME_SEQ]) {
assert (frame[FRAME_SEQ].length == 8);
ByteBuffer source = ByteBuffer.wrap(frame[FRAME_SEQ]);
return source.getLong();
}
else
return 0;
}
// Set message getSequence number
public void setSequence(long sequence)
{
ByteBuffer msg = ByteBuffer.allocate(8);
msg.putLong(sequence);
present[FRAME_SEQ] = true;
frame[FRAME_SEQ] = msg.array();
}
// Return body from last read message, if any, else NULL
public byte[] body()
{
if (present[FRAME_BODY])
return frame[FRAME_BODY];
else
return null;
}
// Set message body
public void setBody(byte[] body)
{
byte[] msg = new byte[body.length];
System.arraycopy(body, 0, msg, 0, body.length);
frame [FRAME_BODY] = msg;
present[FRAME_BODY] = true;
}
// Set message body using printf format
public void fmtBody(String fmt, Object... args)
{
setBody(String.format(fmt, args).getBytes(ZMQ.CHARSET));
}
// Return body size from last read message, if any, else zero
public int size()
{
if (present[FRAME_BODY])
return frame[FRAME_BODY].length;
else
return 0;
}
// .until
// .split UUID methods
// These methods get and set the UUID for the getKey-value message:
public byte[] UUID()
{
if (present[FRAME_UUID])
return frame[FRAME_UUID];
else
return null;
}
// Sets the UUID to a randomly generated value
public void setUUID()
{
byte[] msg = UUID.randomUUID().toString().getBytes(ZMQ.CHARSET);
present[FRAME_UUID] = true;
frame[FRAME_UUID] = msg;
}
// .split property methods
// These methods get and set a specified message property:
// Get message property, return "" if no such property is defined.
public String getProp(String name)
{
return props.getProperty(name, "");
}
// Set message property. Property name cannot contain '='. Max length of
// value is 255 chars.
public void setProp(String name, String fmt, Object ... args)
{
String value = String.format(fmt, args);
Object old = props.setProperty(name, value);
if (old != null)
props_size -= old.toString().length();
else
props_size += name.length() + 2;
props_size += value.length();
}
// .split store method
// This method stores the getKey-value message into a hash map, unless
// the getKey and value are both null. It nullifies the {{kvmsg}} reference
// so that the object is owned by the hash map, not the caller:
public void store(Map hash)
{
if (size() > 0) {
if (present[FRAME_KEY] && present[FRAME_BODY]) {
hash.put(getKey(), this);
}
} else
hash.remove(getKey());
}
// .split dump method
// This method extends the {{kvsimple}} implementation with support for
// message properties:
public void dump()
{
int size = size();
byte[] body = body();
System.err.printf("[seq:%d]", getSequence());
System.err.printf("[getKey:%s]", getKey());
// .until
System.err.printf("[size:%d] ", size);
System.err.printf("[");
for (String key: props.stringPropertyNames()) {
System.err.printf("%s=%s;", key, props.getProperty(key));
}
System.err.printf("]");
// .skip
for (int charNbr = 0; charNbr < size; charNbr++)
System.err.printf("%02X", body[charNbr]);
System.err.printf("\n");
}
// .until
// .split test method
// This method is the same as in {{kvsimple}} with added support
// for the uuid and property features of {{kvmsg}}:
public void test(boolean verbose)
{
System.out.printf(" * kvmsg: ");
// Prepare our context and sockets
ZContext ctx = new ZContext();
Socket output = ctx.createSocket(ZMQ.DEALER);
output.bind("ipc://kvmsg_selftest.ipc");
Socket input = ctx.createSocket(ZMQ.DEALER);
input.connect("ipc://kvmsg_selftest.ipc");
Map kvmap = new HashMap();
// .until
// Test send and receive of simple message
kvmsg kvmsg = new kvmsg(1);
kvmsg.setKey("getKey");
kvmsg.setUUID();
kvmsg.setBody("body".getBytes(ZMQ.CHARSET));
if (verbose)
kvmsg.dump();
kvmsg.send(output);
kvmsg.store(kvmap);
kvmsg = kvmsg.recv(input);
if (verbose)
kvmsg.dump();
assert (kvmsg.getKey().equals("getKey"));
kvmsg.store(kvmap);
// Test send and receive of message with properties
kvmsg = new kvmsg(2);
kvmsg.setProp("prop1", "value1");
kvmsg.setProp("prop2", "value1");
kvmsg.setProp("prop2", "value2");
kvmsg.setKey("getKey");
kvmsg.setUUID();
kvmsg.setBody("body".getBytes(ZMQ.CHARSET));
assert (kvmsg.getProp("prop2").equals("value2"));
if (verbose)
kvmsg.dump();
kvmsg.send(output);
kvmsg.destroy();
kvmsg = kvmsg.recv(input);
if (verbose)
kvmsg.dump();
assert (kvmsg.key.equals("getKey"));
assert (kvmsg.getProp("prop2").equals("value2"));
kvmsg.destroy();
// .skip
// Shutdown and destroy all objects
ctx.destroy();
System.out.printf("OK\n");
}
// .until
}
jeromq-0.3.5/src/test/java/guide/kvsimple.java 0000664 0000000 0000000 00000006122 12551504772 0021306 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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
*
*/
public class kvsimple {
private final String key;
private long sequence;
private final byte[] body;
public kvsimple(String key, long sequence, byte[] body) {
this.key = key;
this.sequence = sequence;
this.body = body; // clone if needed
}
public String getKey() {
return key;
}
public long getSequence() {
return sequence;
}
public void setSequence(long sequence)
{
this.sequence = sequence;
}
public byte[] getBody() {
return body;
}
public void send(Socket publisher) {
publisher.send(key.getBytes(ZMQ.CHARSET), ZMQ.SNDMORE);
ByteBuffer bb = ByteBuffer.allocate(8);
bb.asLongBuffer().put(sequence);
publisher.send(bb.array(), ZMQ.SNDMORE);
publisher.send(body, 0);
}
public static kvsimple recv(Socket updates) {
byte [] data = updates.recv(0);
if (data == null || !updates.hasReceiveMore())
return null;
String key = new String(data, ZMQ.CHARSET);
data = updates.recv(0);
if (data == null || !updates.hasReceiveMore())
return null;
Long sequence = ByteBuffer.wrap(data).getLong();
byte[] body = updates.recv(0);
if (body == null || updates.hasReceiveMore())
return null;
return new kvsimple(key, sequence, body);
}
@Override
public String toString() {
return "kvsimple [getKey=" + key + ", getSequence=" + sequence + ", body=" + Arrays.toString(body) + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + Arrays.hashCode(body);
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + (int) (sequence ^ (sequence >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
kvsimple other = (kvsimple) obj;
if (!Arrays.equals(body, other.body))
return false;
if (key == null) {
if (other.key != null)
return false;
} else if (!key.equals(other.key))
return false;
if (sequence != other.sequence)
return false;
return true;
}
}
jeromq-0.3.5/src/test/java/guide/lbbroker.java 0000664 0000000 0000000 00000015613 12551504772 0021263 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workerQueue = new LinkedList();
while (!Thread.currentThread().isInterrupted()) {
// Initialize poll set
Poller items = new Poller (2);
//  Always poll for worker activity on backend
items.register(backend, Poller.POLLIN);
//  Poll front-end only if we have available workers
if(workerQueue.size() > 0)
items.register(frontend, Poller.POLLIN);
if (items.poll() < 0)
break; // Interrupted
// Handle worker activity on backend
if (items.pollin(0)) {
// Queue worker address for LRU routing
workerQueue.add (backend.recvStr ());
// Second frame is empty
String empty = backend.recvStr ();
assert (empty.length() == 0);
// Third frame is READY or else a client reply address
String clientAddr = backend.recvStr ();
// If client reply, send rest back to frontend
if (!clientAddr.equals("READY")) {
empty = backend.recvStr ();
assert (empty.length() == 0);
String reply = backend.recvStr ();
frontend.sendMore(clientAddr);
frontend.sendMore("");
frontend.send(reply);
if (--clientNbr == 0)
break;
}
}
if (items.pollin(1)) {
// Now get next client request, route to LRU worker
// Client request is [address][empty][request]
String clientAddr = frontend.recvStr ();
String empty = frontend.recvStr ();
assert (empty.length() == 0);
String request = frontend.recvStr ();
String workerAddr = workerQueue.poll();
backend.sendMore (workerAddr);
backend.sendMore ("");
backend.sendMore (clientAddr );
backend.sendMore ("");
backend.send (request);
}
}
frontend.close();
backend.close();
context.term();
}
}
jeromq-0.3.5/src/test/java/guide/lbbroker2.java 0000664 0000000 0000000 00000013064 12551504772 0021343 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workerQueue = new LinkedList ();
// Here is the main loop for the load-balancer. It works the same way
// as the previous example, but is a lot shorter because ZMsg class gives
// us an API that does more with fewer calls:
while (!Thread.currentThread().isInterrupted()) {
// Initialize poll set
Poller items = new Poller (2);
//  Always poll for worker activity on backend
items.register(backend, Poller.POLLIN);
//  Poll front-end only if we have available workers
if(workerQueue.size() > 0)
items.register(frontend, Poller.POLLIN);
if (items.poll() < 0)
break; // Interrupted
// Handle worker activity on backend
if (items.pollin(0)) {
ZMsg msg = ZMsg.recvMsg (backend);
if (msg == null)
break; // Interrupted
ZFrame identity = msg.unwrap ();
// Queue worker address for LRU routing
workerQueue.add (identity);
// Forward message to client if it's not a READY
ZFrame frame = msg.getFirst ();
if (Arrays.equals (frame.getData (), WORKER_READY))
msg.destroy ();
else
msg.send (frontend);
}
if (items.pollin(1)) {
// Get client request, route to first available worker
ZMsg msg = ZMsg.recvMsg (frontend);
if (msg != null) {
msg.wrap (workerQueue.poll ());
msg.send (backend);
}
}
}
context.destroy ();
}
}
jeromq-0.3.5/src/test/java/guide/lbbroker3.java 0000664 0000000 0000000 00000014676 12551504772 0021356 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers; // List of ready workers
};
/**
* In the reactor design, each time a message arrives on a socket, the
* reactor passes it to a handler function. We have two handlers; one
* for the frontend, one for the backend:
*/
private static class FrontendHandler implements ZLoop.IZLoopHandler {
@Override
public int handle(ZLoop loop, PollItem item, Object arg_) {
LBBroker arg = (LBBroker)arg_;
ZMsg msg = ZMsg.recvMsg (arg.frontend);
if (msg != null) {
msg.wrap(arg.workers.poll());
msg.send(arg.backend);
// Cancel reader on frontend if we went from 1 to 0 workers
if (arg.workers.size() == 0) {
loop.removePoller (new PollItem (arg.frontend, 0));
}
}
return 0;
}
}
private static class BackendHandler implements ZLoop.IZLoopHandler {
@Override
public int handle(ZLoop loop, PollItem item, Object arg_) {
LBBroker arg = (LBBroker)arg_;
ZMsg msg = ZMsg.recvMsg(arg.backend);
if (msg != null) {
ZFrame address = msg.unwrap();
// Queue worker address for load-balancing
arg.workers.add(address);
// Enable reader on frontend if we went from 0 to 1 workers
if (arg.workers.size() == 1) {
PollItem newItem = new PollItem (arg.frontend, ZMQ.Poller.POLLIN);
loop.addPoller (newItem, frontendHandler, arg);
}
// Forward message to client if it's not a READY
ZFrame frame = msg.getFirst();
if (Arrays.equals (frame.getData(), WORKER_READY))
msg.destroy();
else
msg.send(arg.frontend);
}
return 0;
}
}
private final static FrontendHandler frontendHandler = new FrontendHandler();
private final static BackendHandler backendHandler = new BackendHandler();
/**
* And the main task now sets-up child tasks, then starts its reactor.
* If you press Ctrl-C, the reactor exits and the main task shuts down.
*/
public static void main (String[] args) {
ZContext context = new ZContext();
LBBroker arg = new LBBroker ();
// Prepare our context and sockets
arg.frontend = context.createSocket (ZMQ.ROUTER);
arg.backend = context.createSocket (ZMQ.ROUTER);
arg.frontend.bind("ipc://frontend.ipc");
arg.backend.bind("ipc://backend.ipc");
int clientNbr;
for (clientNbr = 0; clientNbr < NBR_CLIENTS; clientNbr++)
ZThread.start (new ClientTask ());
for (int workerNbr = 0; workerNbr < NBR_WORKERS; workerNbr++)
ZThread.start (new WorkerTask ());
// Queue of available workers
arg.workers = new LinkedList ();
// Prepare reactor and fire it up
ZLoop reactor = new ZLoop ();
PollItem item = new PollItem (arg.backend, ZMQ.Poller.POLLIN);
reactor.addPoller (item, backendHandler, arg);
reactor.start ();
context.destroy ();
}
}
jeromq-0.3.5/src/test/java/guide/lpclient.java 0000664 0000000 0000000 00000007513 12551504772 0021273 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers; // List of ready workers
};
//In the reactor design, each time a message arrives on a socket, the
//reactor passes it to a handler function. We have two handlers; one
//for the frontend, one for the backend:
class FrontendHandler implements ZLoop.IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg_)
{
LRUQueueArg arg = (LRUQueueArg) arg_;
ZMsg msg = ZMsg.recvMsg(arg.frontend);
if (msg != null) {
msg.wrap(arg.workers.poll());
msg.send(arg.backend);
// Cancel reader on frontend if we went from 1 to 0 workers
if (arg.workers.size() == 0) {
PollItem poller = new PollItem(arg.frontend, ZMQ.Poller.POLLIN);
loop.removePoller(poller);
}
}
return 0;
}
}
class BackendHandler implements ZLoop.IZLoopHandler
{
@Override
public int handle(ZLoop loop, PollItem item, Object arg_)
{
LRUQueueArg arg = (LRUQueueArg) arg_;
ZMsg msg = ZMsg.recvMsg(arg.backend);
if (msg != null) {
ZFrame address = msg.unwrap();
// Queue worker address for LRU routing
arg.workers.add(address);
// Enable reader on frontend if we went from 0 to 1 workers
if (arg.workers.size() == 1) {
PollItem poller = new PollItem(arg.frontend, ZMQ.Poller.POLLIN);
loop.addPoller(poller, lruqueue3.handle_frontend, arg);
}
// Forward message to client if it's not a READY
ZFrame frame = msg.getFirst();
if (new String(frame.getData(), ZMQ.CHARSET).equals(lruqueue3.LRU_READY))
msg.destroy();
else
msg.send(arg.frontend);
}
return 0;
}
}
public class lruqueue3
{
public final static String LRU_READY = "\001";
protected final static FrontendHandler handle_frontend = new FrontendHandler();
protected final static BackendHandler handle_backend = new BackendHandler();
public static void main(String[] args)
{
ZContext context = new ZContext();
LRUQueueArg arg = new LRUQueueArg();
// Prepare our context and sockets
Socket frontend = context.createSocket(ZMQ.ROUTER);
Socket backend = context.createSocket(ZMQ.ROUTER);
arg.frontend = frontend;
arg.backend = backend;
frontend.bind("ipc://frontend.ipc");
backend.bind("ipc://backend.ipc");
int client_nbr;
for (client_nbr = 0; client_nbr < 10; client_nbr++)
new ClientThread3().start();
int worker_nbr;
for (worker_nbr = 0; worker_nbr < 3; worker_nbr++)
new WorkerThread3().start();
// Queue of available workers
arg.workers = new LinkedList();
// Prepare reactor and fire it up
ZLoop reactor = new ZLoop();
reactor.verbose(true);
PollItem poller = new PollItem(arg.backend, ZMQ.Poller.POLLIN);
reactor.addPoller(poller, handle_backend, arg);
reactor.start();
reactor.destroy();
for (ZFrame frame : arg.workers) {
frame.destroy();
}
context.destroy();
System.exit(0);
}
}
jeromq-0.3.5/src/test/java/guide/lvcache.java 0000664 0000000 0000000 00000006521 12551504772 0021064 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 cache = new HashMap();
// .split main poll loop
// We route topic updates from frontend to backend, and
// we handle subscriptions by sending whatever we cached,
// if anything:
while (true) {
PollItem[] items = {
new PollItem(frontend, ZMQ.Poller.POLLIN),
new PollItem(backend, ZMQ.Poller.POLLIN),
};
if (ZMQ.poll(items, 1000) == -1)
break; // Interrupted
// Any new topic data we cache and then forward
if (items[0].isReadable()) {
String topic = frontend.recvStr();
String current = frontend.recvStr();
if (topic == null)
break;
cache.put(topic, current);
backend.sendMore(topic);
backend.send(current);
}
// .split handle subscriptions
// When we get a new subscription, we pull data from the cache:
if (items[1].isReadable()) {
ZFrame frame = ZFrame.recvFrame(backend);
if (frame == null)
break;
// Event is one byte 0=unsub or 1=sub, followed by topic
byte[] event = frame.getData();
if (event [0] == 1) {
String topic = new String(event, 1, event.length -1, ZMQ.CHARSET);
System.out.printf ("Sending cached topic %s\n", topic);
String previous = cache.get(topic);
if (previous != null) {
backend.sendMore(topic);
backend.send(previous);
}
}
frame.destroy();
}
}
context.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/mdbroker.java 0000664 0000000 0000000 00000031766 12551504772 0021275 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 requests; // List of client requests
Deque waiting; // List of waiting workers
public Service(String name) {
this.name = name;
this.requests = new ArrayDeque();
this.waiting = new ArrayDeque();
}
}
/**
* This defines one worker, idle or active.
*/
private static class Worker {
String identity;// Identity of worker
ZFrame address;// Address frame to route to
Service service; // Owning service, if known
long expiry;// Expires at unless heartbeat
public Worker(String identity, ZFrame address) {
this.address = address;
this.identity = identity;
this.expiry = System.currentTimeMillis() + HEARTBEAT_INTERVAL
* HEARTBEAT_LIVENESS;
}
}
// ---------------------------------------------------------------------
private ZContext ctx;// Our context
private ZMQ.Socket socket; // Socket for clients & workers
private long heartbeatAt;// When to send HEARTBEAT
private Map services;// known services
private Map workers;// known workers
private Deque waiting;// idle workers
private boolean verbose = false;// Print activity to stdout
private Formatter log = new Formatter(System.out);
// ---------------------------------------------------------------------
/**
* Main method - create and start new broker.
*/
public static void main(String[] args) {
mdbroker broker = new mdbroker(args.length > 0 && "-v".equals(args[0]));
// Can be called multiple times with different endpoints
broker.bind("tcp://*:5555");
broker.mediate();
}
/**
* Initialize broker state.
*/
public mdbroker(boolean verbose) {
this.verbose = verbose;
this.services = new HashMap();
this.workers = new HashMap();
this.waiting = new ArrayDeque();
this.heartbeatAt = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
this.ctx = new ZContext();
this.socket = ctx.createSocket(ZMQ.ROUTER);
}
// ---------------------------------------------------------------------
/**
* Main broker work happens here
*/
public void mediate() {
while (!Thread.currentThread().isInterrupted()) {
ZMQ.Poller items = new ZMQ.Poller(1);
items.register(socket, ZMQ.Poller.POLLIN);
if (items.poll(HEARTBEAT_INTERVAL) == -1)
break; // Interrupted
if (items.pollin(0)) {
ZMsg msg = ZMsg.recvMsg(socket);
if (msg == null)
break; // Interrupted
if (verbose) {
log.format("I: received message:\n");
msg.dump(log.out());
}
ZFrame sender = msg.pop();
ZFrame empty = msg.pop();
ZFrame header = msg.pop();
if (MDP.C_CLIENT.frameEquals(header)) {
processClient(sender, msg);
} else if (MDP.W_WORKER.frameEquals(header))
processWorker(sender, msg);
else {
log.format("E: invalid message:\n");
msg.dump(log.out());
msg.destroy();
}
sender.destroy();
empty.destroy();
header.destroy();
}
purgeWorkers();
sendHeartbeats();
}
destroy(); // interrupted
}
/**
* Disconnect all workers, destroy context.
*/
private void destroy() {
Worker[] deleteList = workers.entrySet().toArray(new Worker[0]);
for (Worker worker : deleteList) {
deleteWorker(worker, true);
}
ctx.destroy();
}
/**
* Process a request coming from a client.
*/
private void processClient(ZFrame sender, ZMsg msg) {
assert (msg.size() >= 2); // Service name + body
ZFrame serviceFrame = msg.pop();
// Set reply return address to client sender
msg.wrap(sender.duplicate());
if (serviceFrame.toString().startsWith(INTERNAL_SERVICE_PREFIX))
serviceInternal(serviceFrame, msg);
else
dispatch(requireService(serviceFrame), msg);
serviceFrame.destroy();
}
/**
* Process message sent to us by a worker.
*/
private void processWorker(ZFrame sender, ZMsg msg) {
assert (msg.size() >= 1); // At least, command
ZFrame command = msg.pop();
boolean workerReady = workers.containsKey(sender.strhex());
Worker worker = requireWorker(sender);
if (MDP.W_READY.frameEquals(command)) {
// Not first command in session || Reserved service name
if (workerReady
|| sender.toString().startsWith(INTERNAL_SERVICE_PREFIX))
deleteWorker(worker, true);
else {
// Attach worker to service and mark as idle
ZFrame serviceFrame = msg.pop();
worker.service = requireService(serviceFrame);
workerWaiting(worker);
serviceFrame.destroy();
}
} else if (MDP.W_REPLY.frameEquals(command)) {
if (workerReady) {
// Remove & save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
ZFrame client = msg.unwrap();
msg.addFirst(worker.service.name);
msg.addFirst(MDP.C_CLIENT.newFrame());
msg.wrap(client);
msg.send(socket);
workerWaiting(worker);
} else {
deleteWorker(worker, true);
}
} else if (MDP.W_HEARTBEAT.frameEquals(command)) {
if (workerReady) {
worker.expiry = System.currentTimeMillis() + HEARTBEAT_EXPIRY;
} else {
deleteWorker(worker, true);
}
} else if (MDP.W_DISCONNECT.frameEquals(command))
deleteWorker(worker, false);
else {
log.format("E: invalid message:\n");
msg.dump(log.out());
}
msg.destroy();
}
/**
* Deletes worker from all data structures, and destroys worker.
*/
private void deleteWorker(Worker worker, boolean disconnect) {
assert (worker != null);
if (disconnect) {
sendToWorker(worker, MDP.W_DISCONNECT, null, null);
}
if (worker.service != null)
worker.service.waiting.remove(worker);
workers.remove(worker);
worker.address.destroy();
}
/**
* Finds the worker (creates if necessary).
*/
private Worker requireWorker(ZFrame address) {
assert (address != null);
String identity = address.strhex();
Worker worker = workers.get(identity);
if (worker == null) {
worker = new Worker(identity, address.duplicate());
workers.put(identity, worker);
if (verbose)
log.format("I: registering new worker: %s\n", identity);
}
return worker;
}
/**
* Locates the service (creates if necessary).
*/
private Service requireService(ZFrame serviceFrame) {
assert (serviceFrame != null);
String name = serviceFrame.toString();
Service service = services.get(name);
if (service == null) {
service = new Service(name);
services.put(name, service);
}
return service;
}
/**
* Bind broker to endpoint, can call this multiple times. We use a single
* socket for both clients and workers.
*/
private void bind(String endpoint) {
socket.bind(endpoint);
log.format("I: MDP broker/0.1.1 is active at %s\n", endpoint);
}
/**
* Handle internal service according to 8/MMI specification
*/
private void serviceInternal(ZFrame serviceFrame, ZMsg msg) {
String returnCode = "501";
if ("mmi.service".equals(serviceFrame.toString())) {
String name = msg.peekLast().toString();
returnCode = services.containsKey(name) ? "200" : "400";
}
msg.peekLast().reset(returnCode.getBytes(ZMQ.CHARSET));
// Remove & save client return envelope and insert the
// protocol header and service name, then rewrap envelope.
ZFrame client = msg.unwrap();
msg.addFirst(serviceFrame.duplicate());
msg.addFirst(MDP.C_CLIENT.newFrame());
msg.wrap(client);
msg.send(socket);
}
/**
* Send heartbeats to idle workers if it's time
*/
public synchronized void sendHeartbeats() {
// Send heartbeats to idle workers if it's time
if (System.currentTimeMillis() >= heartbeatAt) {
for (Worker worker : waiting) {
sendToWorker(worker, MDP.W_HEARTBEAT, null, null);
}
heartbeatAt = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
}
}
/**
* Look for & kill expired workers. Workers are oldest to most recent, so we
* stop at the first alive worker.
*/
public synchronized void purgeWorkers() {
for (Worker w = waiting.peekFirst(); w != null
&& w.expiry < System.currentTimeMillis(); w = waiting
.peekFirst()) {
log.format("I: deleting expired worker: %s\n", w.identity);
deleteWorker(waiting.pollFirst(), false);
}
}
/**
* This worker is now waiting for work.
*/
public synchronized void workerWaiting(Worker worker) {
// Queue to broker and service waiting lists
waiting.addLast(worker);
worker.service.waiting.addLast(worker);
worker.expiry = System.currentTimeMillis() + HEARTBEAT_EXPIRY;
dispatch(worker.service, null);
}
/**
* Dispatch requests to waiting workers as possible
*/
private void dispatch(Service service, ZMsg msg) {
assert (service != null);
if (msg != null)// Queue message if any
service.requests.offerLast(msg);
purgeWorkers();
while (!service.waiting.isEmpty() && !service.requests.isEmpty()) {
msg = service.requests.pop();
Worker worker = service.waiting.pop();
waiting.remove(worker);
sendToWorker(worker, MDP.W_REQUEST, null, msg);
msg.destroy();
}
}
/**
* Send message to worker. If message is provided, sends that message. Does
* not destroy the message, this is the caller's job.
*/
public void sendToWorker(Worker worker, MDP command, String option,
ZMsg msgp) {
ZMsg msg = msgp == null ? new ZMsg() : msgp.duplicate();
// Stack protocol envelope to start of message
if (option != null)
msg.addFirst(new ZFrame(option));
msg.addFirst(command.newFrame());
msg.addFirst(MDP.W_WORKER.newFrame());
// Stack routing envelope to start of message
msg.wrap(worker.address.duplicate());
if (verbose) {
log.format("I: sending %s to worker\n", command);
msg.dump(log.out());
}
msg.send(socket);
}
}
jeromq-0.3.5/src/test/java/guide/mdcliapi.java 0000664 0000000 0000000 00000010201 12551504772 0021227 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers = new ArrayList();
while (true) {
// First, route any waiting replies from workers
PollItem backends[] = {
new PollItem(localbe, Poller.POLLIN),
new PollItem(cloudbe, Poller.POLLIN)
};
// If we have no workers anyhow, wait indefinitely
int rc = ZMQ.poll(backends,
capacity > 0 ? 1000 : -1);
if (rc == -1)
break; // Interrupted
// Handle reply from local worker
ZMsg msg = null;
if (backends[0].isReadable()) {
msg = ZMsg.recvMsg(localbe);
if (msg == null)
break; // Interrupted
ZFrame address = msg.unwrap();
workers.add(address);
capacity++;
// If it's READY, don't route the message any further
ZFrame frame = msg.getFirst();
if (new String(frame.getData(), ZMQ.CHARSET).equals(WORKER_READY)) {
msg.destroy();
msg = null;
}
}
// Or handle reply from peer broker
else if (backends[1].isReadable()) {
msg = ZMsg.recvMsg(cloudbe);
if (msg == null)
break; // Interrupted
// We don't use peer broker address for anything
ZFrame address = msg.unwrap();
address.destroy();
}
// Route reply to cloud if it's addressed to a broker
for (argn = 1; msg != null && argn < argv.length; argn++) {
byte[] data = msg.getFirst().getData();
if (argv[argn].equals(new String(data, ZMQ.CHARSET))) {
msg.send(cloudfe);
msg = null;
}
}
// Route reply to client if we still need to
if (msg != null)
msg.send(localfe);
// Now we route as many client requests as we have worker capacity
// for. We may reroute requests from our local frontend, but not from //
// the cloud frontend. We reroute randomly now, just to test things
// out. In the next version we'll do this properly by calculating
// cloud capacity://
while (capacity > 0) {
PollItem frontends[] = {
new PollItem(localfe, Poller.POLLIN),
new PollItem(cloudfe, Poller.POLLIN)
};
rc = ZMQ.poll(frontends, 0);
assert (rc >= 0);
int reroutable = 0;
// We'll do peer brokers first, to prevent starvation
if (frontends[1].isReadable()) {
msg = ZMsg.recvMsg(cloudfe);
reroutable = 0;
} else if (frontends[0].isReadable()) {
msg = ZMsg.recvMsg(localfe);
reroutable = 1;
} else
break; // No work, go back to backends
// If reroutable, send to cloud 20% of the time
// Here we'd normally use cloud status information
//
if (reroutable != 0 && argv.length > 1 && rand.nextInt(5) == 0) {
// Route to random broker peer
int random_peer = rand.nextInt(argv.length - 1) + 1;
msg.push(argv[random_peer]);
msg.send(cloudbe);
} else {
ZFrame frame = workers.remove(0);
msg.wrap(frame);
msg.send(localbe);
capacity--;
}
}
}
// When we're done, clean up properly
while (workers.size() > 0) {
ZFrame frame = workers.remove(0);
frame.destroy();
}
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/peering3.java 0000664 0000000 0000000 00000031726 12551504772 0021200 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers = new ArrayList();
// The main loop has two parts. First we poll workers and our two service
// sockets (statefe and monitor), in any case. If we have no ready workers,
// there's no point in looking at incoming requests. These can remain on
// their internal 0MQ queues:
while (true) {
// First, route any waiting replies from workers
PollItem primary[] = {
new PollItem(localbe, Poller.POLLIN),
new PollItem(cloudbe, Poller.POLLIN),
new PollItem(statefe, Poller.POLLIN),
new PollItem(monitor, Poller.POLLIN)
};
// If we have no workers anyhow, wait indefinitely
int rc = ZMQ.poll(primary,
localCapacity > 0 ? 1000 : -1);
if (rc == -1)
break; // Interrupted
// Track if capacity changes during this iteration
int previous = localCapacity;
// Handle reply from local worker
ZMsg msg = null;
if (primary[0].isReadable()) {
msg = ZMsg.recvMsg(localbe);
if (msg == null)
break; // Interrupted
ZFrame address = msg.unwrap();
workers.add(address);
localCapacity++;
// If it's READY, don't route the message any further
ZFrame frame = msg.getFirst();
if (new String(frame.getData(), ZMQ.CHARSET).equals(WORKER_READY)) {
msg.destroy();
msg = null;
}
}
// Or handle reply from peer broker
else if (primary[1].isReadable()) {
msg = ZMsg.recvMsg(cloudbe);
if (msg == null)
break; // Interrupted
// We don't use peer broker address for anything
ZFrame address = msg.unwrap();
address.destroy();
}
// Route reply to cloud if it's addressed to a broker
for (argn = 1; msg != null && argn < argv.length; argn++) {
byte[] data = msg.getFirst().getData();
if (argv[argn].equals(new String(data, ZMQ.CHARSET))) {
msg.send(cloudfe);
msg = null;
}
}
// Route reply to client if we still need to
if (msg != null)
msg.send(localfe);
// If we have input messages on our statefe or monitor sockets we
// can process these immediately:
if (primary[2].isReadable()) {
String peer = statefe.recvStr();
String status = statefe.recvStr();
cloudCapacity = Integer.parseInt(status);
}
if (primary[3].isReadable()) {
String status = monitor.recvStr();
System.out.println(status);
}
// Now we route as many client requests as we have worker capacity
// for. We may reroute requests from our local frontend, but not from //
// the cloud frontend. We reroute randomly now, just to test things
// out. In the next version we'll do this properly by calculating
// cloud capacity://
while (localCapacity + cloudCapacity > 0) {
PollItem secondary[] = {
new PollItem(localfe, Poller.POLLIN),
new PollItem(cloudfe, Poller.POLLIN)
};
if (localCapacity > 0)
rc = ZMQ.poll(secondary, 2, 0);
else
rc = ZMQ.poll(secondary, 1, 0);
assert (rc >= 0);
if (secondary[0].isReadable()) {
msg = ZMsg.recvMsg(localfe);
} else if (secondary[1].isReadable()) {
msg = ZMsg.recvMsg(cloudfe);
} else
break; // No work, go back to backends
if (localCapacity > 0) {
ZFrame frame = workers.remove(0);
msg.wrap(frame);
msg.send(localbe);
localCapacity--;
} else {
// Route to random broker peer
int random_peer = rand.nextInt(argv.length - 1) + 1;
msg.push(argv[random_peer]);
msg.send(cloudbe);
}
}
// We broadcast capacity messages to other peers; to reduce chatter
// we do this only if our capacity changed.
if (localCapacity != previous) {
// We stick our own address onto the envelope
statebe.sendMore(self);
// Broadcast new capacity
statebe.send(String.format("%d", localCapacity), 0);
}
}
// When we're done, clean up properly
while (workers.size() > 0) {
ZFrame frame = workers.remove(0);
frame.destroy();
}
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/ppqueue.java 0000664 0000000 0000000 00000015243 12551504772 0021144 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers) {
Iterator it = workers.iterator();
while (it.hasNext()) {
Worker worker = it.next();
if (identity.equals(worker.identity)) {
it.remove();
break;
}
}
workers.add(this);
}
// The next method returns the next available worker address:
protected static ZFrame next(ArrayList workers) {
Worker worker = workers.remove(0);
assert (worker != null);
ZFrame frame = worker.address;
return frame;
}
// The purge method looks for and kills expired workers. We hold workers
// from oldest to most recent, so we stop at the first alive worker:
protected static void purge(ArrayList workers) {
Iterator it = workers.iterator();
while (it.hasNext()) {
Worker worker = it.next();
if (System.currentTimeMillis() < worker.expiry) {
break;
}
it.remove();
}
}
};
// The main task is an LRU queue with heartbeating on workers so we can
// detect crashed or blocked worker tasks:
public static void main(String[] args) {
ZContext ctx = new ZContext ();
Socket frontend = ctx.createSocket(ZMQ.ROUTER);
Socket backend = ctx.createSocket(ZMQ.ROUTER);
frontend.bind( "tcp://*:5555"); // For clients
backend.bind( "tcp://*:5556"); // For workers
// List of available workers
ArrayList workers = new ArrayList ();
// Send out heartbeats at regular intervals
long heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
while (true) {
PollItem items [] = {
new PollItem( backend, ZMQ.Poller.POLLIN ),
new PollItem( frontend, ZMQ.Poller.POLLIN )
};
// Poll frontend only if we have available workers
int rc = ZMQ.poll (items, workers.size() > 0 ? 2:1,
HEARTBEAT_INTERVAL );
if (rc == -1)
break; // Interrupted
// Handle worker activity on backend
if (items [0].isReadable()) {
// Use worker address for LRU routing
ZMsg msg = ZMsg.recvMsg (backend);
if (msg == null)
break; // Interrupted
// Any sign of life from worker means it's ready
ZFrame address = msg.unwrap();
Worker worker = new Worker(address);
worker.ready(workers);
// Validate control message, or return reply to client
if (msg.size() == 1) {
ZFrame frame = msg.getFirst();
String data = new String(frame.getData(), ZMQ.CHARSET);
if (!data.equals(PPP_READY)
&& !data.equals( PPP_HEARTBEAT)) {
System.out.println ("E: invalid message from worker");
msg.dump(System.out);
}
msg.destroy();
}
else
msg.send(frontend);
}
if (items [1].isReadable()) {
// Now get next client request, route to next worker
ZMsg msg = ZMsg.recvMsg (frontend);
if (msg == null)
break; // Interrupted
msg.push(Worker.next(workers));
msg.send( backend);
}
// We handle heartbeating after any socket activity. First we send
// heartbeats to any idle workers if it's time. Then we purge any
// dead workers:
if (System.currentTimeMillis() >= heartbeat_at) {
for (Worker worker: workers) {
worker.address.send(backend,
ZFrame.REUSE + ZFrame.MORE);
ZFrame frame = new ZFrame (PPP_HEARTBEAT);
frame.send(backend, 0);
}
heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
}
Worker.purge (workers);
}
// When we're done, clean up properly
while ( workers.size() > 0) {
Worker worker = workers.remove(0);
}
workers.clear();
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/ppworker.java 0000664 0000000 0000000 00000015341 12551504772 0021330 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 workers = new ArrayList();
// The body of this example is exactly the same as lruqueue2.
while (true) {
PollItem items[] = {
new PollItem(backend, Poller.POLLIN),
new PollItem(frontend, Poller.POLLIN)
};
int rc = ZMQ.poll(items, workers.size() > 0 ? 2 : 1, -1);
// Poll frontend only if we have available workers
if (rc == -1)
break; // Interrupted
// Handle worker activity on backend
if (items[0].isReadable()) {
// Use worker address for LRU routing
ZMsg msg = ZMsg.recvMsg(backend);
if (msg == null)
break; // Interrupted
ZFrame address = msg.unwrap();
workers.add(address);
// Forward message to client if it's not a READY
ZFrame frame = msg.getFirst();
if (new String(frame.getData(), ZMQ.CHARSET).equals(WORKER_READY))
msg.destroy();
else
msg.send(frontend);
}
if (items[1].isReadable()) {
// Get client request, route to first available worker
ZMsg msg = ZMsg.recvMsg(frontend);
if (msg != null) {
msg.wrap(workers.remove(0));
msg.send(backend);
}
}
}
// When we're done, clean up properly
while (workers.size() > 0) {
ZFrame frame = workers.remove(0);
frame.destroy();
}
workers.clear();
ctx.destroy();
}
}
jeromq-0.3.5/src/test/java/guide/spworker.java 0000664 0000000 0000000 00000005153 12551504772 0021333 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 createSockets(ZContext ctx, Object[] args)
{
assert ("TEST".equals(args[0]));
return Arrays.asList(ctx.createSocket(ZMQ.PUB));
}
@Override
public boolean backstage(Socket pipe, ZPoller poller, int events)
{
String string = pipe.recvStr();
if ("HELLO".equals(string)) {
pipe.send("WORLD");
return false;
}
return true;
}
};
ZActor actor = new ZActor(acting, "LOCK", Arrays.asList("TEST").toArray());
Socket pipe = actor.pipe();
boolean rc = pipe.send("HELLO");
Assert.assertTrue("Unable to send a message through pipe", rc);
ZMsg msg = actor.recv();
String world = msg.popString();
Assert.assertEquals("No matching response from actor", "WORLD", world);
msg = actor.recv();
Assert.assertNull("Able te receive a message from a locked actor", msg);
rc = actor.sign();
Assert.assertFalse("Locked actor is still here", rc);
rc = actor.send("whatever");
Assert.assertFalse("Able to send a message to a locked actor", rc);
try {
rc = pipe.send("boom ?!");
Assert.assertTrue("actor pipe was closed pretty fast", rc);
}
catch (ZMQException e) {
int errno = e.getErrorCode();
Assert.assertEquals("Expected exception has the wrong code", ZError.ETERM, errno);
}
System.out.println(".");
}
@Test
public void testRecreateAgent()
{
MiniActor acting = new MiniActor()
{
private int counter = 0;
@Override
public List createSockets(ZContext ctx, Object[] args)
{
++counter;
System.out.print(".Acting Ready for a hello world.");
assert ("TEST".equals(args[0]));
return super.createSockets(ctx, args);
}
@Override
public boolean backstage(Socket pipe, ZPoller poller, int events)
{
String string = pipe.recvStr();
if ("HELLO".equals(string)) {
System.out.print("Hi! ");
pipe.send("WORLD", ZMQ.SNDMORE);
pipe.send(Integer.toString(counter));
return false;
}
return true;
}
public boolean destroyed(Socket pipe, ZPoller poller)
{
if (counter == 2) {
System.out.print(".Acting Finished.");
return false;
}
// recreate a new agent
return true;
}
};
ZActor actor = new ZActor(acting, UUID.randomUUID().toString(), Arrays.asList("TEST").toArray());
ZAgent agent = actor.agent();
agent = actor;
agent = actor.agent();
Socket pipe = agent.pipe();
boolean rc = pipe.send("HELLO");
assert (rc);
ZMsg msg = actor.recv();
String world = msg.popString();
String counter = msg.popString();
assert ("WORLD".equals(world));
assert ("1".equals(counter));
rc = actor.send("HELLO");
assert (rc);
msg = agent.recv();
world = msg.popString();
counter = msg.popString();
assert (msg != null);
assert ("WORLD".equals(world));
assert ("2".equals(counter));
msg = agent.recv();
Assert.assertNull("Able te receive a message from a locked actor", msg);
rc = agent.sign();
Assert.assertFalse("Locked actor is still here", rc);
rc = agent.send("whatever");
Assert.assertFalse("Able to send a message to a locked actor", rc);
try {
rc = pipe.send("boom ?!");
Assert.assertTrue("actor pipe was closed pretty fast", rc);
}
catch (ZMQException e) {
int errno = e.getErrorCode();
Assert.assertEquals("Expected exception has the wrong code", ZError.ETERM, errno);
}
System.out.println();
}
}
jeromq-0.3.5/src/test/java/org/zeromq/TestZContext.java 0000664 0000000 0000000 00000003133 12551504772 0023100 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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 \n");
return;
}
int messageSize = atoi(argv [0]);
int roundtripCount = atoi(argv [1]);
Ctx ctx = ZMQ.init(1);
if (ctx == null) {
printf("error in init:");
return;
}
SocketBase s = ZMQ.socket(ctx, ZMQ.ZMQ_REQ);
if (s == null) {
printf("error in socket: ");
return;
}
boolean rc = ZMQ.bind(s, "inproc://lat_test");
if (!rc) {
printf("error in bind: ");
return;
}
Thread localThread = new Thread(new Worker(ctx, roundtripCount));
localThread.start();
Msg smsg = ZMQ.msgInitWithSize(messageSize);
printf("message size: %d [B]\n", (int) messageSize);
printf("roundtrip count: %d\n", (int) roundtripCount);
long watch = ZMQ.startStopwatch();
for (int i = 0; i != roundtripCount; i++) {
int r = ZMQ.sendMsg(s, smsg, 0);
if (r < 0) {
printf("error in sendmsg: %s\n");
return;
}
Msg msg = ZMQ.recvMsg(s, 0);
if (msg == null) {
printf("error in recvmsg: %s\n");
return;
}
if (ZMQ.msgSize(msg) != messageSize) {
printf("message of incorrect size received\n");
return;
}
}
long elapsed = ZMQ.stopStopwatch(watch);
double latency = (double) elapsed / (roundtripCount * 2);
localThread.join();
printf("average latency: %.3f [us]\n", (double) latency);
ZMQ.close(s);
ZMQ.term(ctx);
}
private static int atoi(String string)
{
return Integer.parseInt(string);
}
private static void printf(String string)
{
System.out.println(string);
}
private static void printf(String string, Object ... args)
{
System.out.println(String.format(string, args));
}
}
jeromq-0.3.5/src/test/java/perf/LocalLat.java 0000664 0000000 0000000 00000005431 12551504772 0021010 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 2007-2014 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