I was wondering if anyone knew of a library that could help me with
some socket programming. Ideally, I'd be able to provide my main
program with a socket connection that would be able to go through a
list of potential targets for connection and then, if the socket died
unexpectedly, try to reach the next potential target. It has to
ultimately use a TCP socket and no I can't use a JMS server
product--but maybe a single part of the library. I saw something
similar to what I want for c# at
http://www.codeproject.com/Articles/20106/Failover-Socket-Client and
I thought that I'd ask around and see if there was some cool library
that I just didn't know about.
It is a actually a tricky problem and I certainly do not like
the approach in the link above.
Below is some half finished (or 1/3 finished) code, that outlines
how I would attack the problem.
Note that making this code robust will certainly take an effort, but
I like the almost transparent usage model (even though the
implementation does violate some OO recommendations).
Example of client code:
List<MultiSocket.Destination> dest = new
ArrayList<MultiSocket.Destination>();
dest.add(new MultiSocket.Destination("localhost", 12345));
dest.add(new MultiSocket.Destination("localhost", 12346));
Socket s = new MultiSocket(dest);
OutputStream os = s.getOutputStream();
InputStream is = s.getInputStream();
int b;
os.write(1);
b = is.read();
Arne
====
import java.io.IOException;
import java.io.InputStream;
import java.i
utputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;
public class MultiSocket extends Socket {
public static class Destination {
private String host;
private int port;
public Destination(String host, int port) {
this.host = host;
this.port = port;
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
}
private List<Socket> alls;
private List<InputStream> allis;
private List<OutputStream> allos;
private int lastwrite;
private byte[] buf;
private int buflen;
private class MultiInputStream extends InputStream {
@Override
public int read() throws IOException {
if(lastwrite < 0) {
throw new IllegalStateException("MultiSocket is only for
request-response");
}
while(alls.size() > 0) {
try {
int b = allis.get(lastwrite).read();
buflen = 0;
return b;
} catch (Exception e) {
remove(lastwrite);
allos.get(0).write(buf, 0, buflen); // additional code is
necessary to handle if this call throws an exception
lastwrite = 0;
}
}
throw new IOException("No working sockets");
}
}
private class MultiOutputStream extends OutputStream {
@Override
public void write(int b) throws IOException {
while(alls.size() > 0) {
try {
buf[buflen] = (byte)b;
buflen++;
allos.get(0).write(b);
lastwrite = 0;
return;
} catch (Exception e) {
remove(0);
allos.get(0).write(buf, 0, buflen); // additional code is
necessary to handle if this call throws an exception
lastwrite = 0;
}
}
throw new IOException("No working sockets");
}
}
private void remove(int ix) {
OutputStream os = allos.remove(ix);
try {
os.close();
} catch(Exception ex) {
// nothing to do
}
InputStream is = allis.remove(ix);
try {
is.close();
} catch(Exception ex) {
// nothing to do
}
Socket s = alls.remove(ix);
try {
s.close();
} catch(Exception ex) {
// nothing to do
}
}
public MultiSocket(List<Destination> dest) throws IOException {
alls = new ArrayList<Socket>();
for(Destination d : dest) {
alls.add(new Socket(d.getHost(), d.getPort()));
}
lastwrite = -1;
buf = new byte[102400];
buflen = 0;
}
@Override
public InputStream getInputStream() throws IOException {
allis = new ArrayList<InputStream>();
for(Socket s : alls) {
allis.add(s.getInputStream());
}
return new MultiInputStream();
}
@Override
public OutputStream getOutputStream() throws IOException {
allos = new ArrayList<OutputStream>();
for(Socket s : alls) {
allos.add(s.getOutputStream());
}
return new MultiOutputStream();
}
@Override
public synchronized void close() throws IOException {
while(alls.size() > 0) {
remove(0);
}
}
// move exception throwing stubs up as they get an implementation that
makes sense
@Override
public void connect(SocketAddress endpoint) throws IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void connect(SocketAddress endpoint, int timeout) throws
IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void bind(SocketAddress bindpoint) throws IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public InetAddress getInetAddress() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public InetAddress getLocalAddress() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public int getPort() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public int getLocalPort() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public SocketAddress getRemoteSocketAddress() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public SocketAddress getLocalSocketAddress() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public SocketChannel getChannel() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setTcpNoDelay(boolean on) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean getTcpNoDelay() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setSoLinger(boolean on, int linger) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public int getSoLinger() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void sendUrgentData(int data) throws IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setOOBInline(boolean on) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean getOOBInline() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized void setSoTimeout(int timeout) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized int getSoTimeout() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized void setSendBufferSize(int size) throws
SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized int getSendBufferSize() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized void setReceiveBufferSize(int size)
throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public synchronized int getReceiveBufferSize() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setKeepAlive(boolean on) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean getKeepAlive() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setTrafficClass(int tc) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public int getTrafficClass() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setReuseAddress(boolean on) throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean getReuseAddress() throws SocketException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void shutdownInput() throws IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void shutdownOutput() throws IOException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public String toString() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean isConnected() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean isBound() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean isClosed() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean isInputShutdown() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean isOutputShutdown() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public void setPerformancePreferences(int connectionTime, int latency,
int bandwidth) {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public int hashCode() {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
public boolean equals(Object obj) {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
protected Object clone() throws CloneNotSupportedException {
throw new RuntimeException("Not supported by MultiSocket");
}
@Override
protected void finalize() throws Throwable {
throw new RuntimeException("Not supported by MultiSocket");
}
}
