high availability and failover for tcp/ip connections

Discussion in 'Java' started by me 2, Jan 18, 2013.

  1. me 2

    me 2 Guest

    Greetings,

    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.

    Cheers,
    Me
    me 2, Jan 18, 2013
    #1
    1. Advertising

  2. me 2

    Arne Vajhøj Guest

    On 1/18/2013 11:00 AM, me 2 wrote:
    > 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.io_OutputStream;
    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");
    }
    }
    Arne Vajhøj, May 19, 2013
    #2
    1. Advertising

  3. me 2

    Joerg Meier Guest

    On Sat, 18 May 2013 19:02:48 -0400, Arne Vajhøj wrote:

    > @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");
    > }


    [...several pages worth...]

    You might want to look into Lombok(-pg):

    -------------
    @AutoGenMethodStub

    With this annotation you can avoid cluttering your code with empty methods
    that an interface forces you to implement. Just implement the ones you need
    and lombok will create stubs for the rest.
    -------------

    For your use case:

    -------------
    @AutoGenMethodStub(throwException = true)
    public class MultiSocket extends Socket { //...
    -------------

    Would then generate a bunch of methods looking like this, waiting for you
    to only override the ones you use:

    -------------
    @Override
    public int getTrafficClass() throws SocketException {
    throw new java.lang.UnsupportedOperationException("This method is not
    implemented yet.");
    }
    -------------

    Lombok is also a compile-time library, so you need not ship it with your
    product (with the exception of their weird function pointers, I believe).

    More info at:
    https://github.com/peichhorn/lombok-pg/wiki/@AutoGenMethodStub

    Because I love Lombok so much, I lombok'ed your class, so you can see them
    next to each other:

    Original (with slight auto-formatter changes):
    http://pastebin.com/EJBcsVdZ

    Lombok'd:
    http://pastebin.com/rUFd47Hc

    Things I changed: cut down the Destination class, cleaned up the remove()
    method, and the aforementioned dummy implementations.

    Liebe Gruesse,
    Joerg

    --
    Ich lese meine Emails nicht, replies to Email bleiben also leider
    ungelesen.
    Joerg Meier, May 19, 2013
    #3
  4. me 2

    bob smith Guest

    On Friday, January 18, 2013 10:00:03 AM UTC-6, me 2 wrote:
    > Greetings,
    >
    >
    >
    > 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 asocket connection that would be able to go through a list of potential targets for connection and then, if the socket died unexpectedly, try to reachthe next potential target. It has to ultimately use a TCP socket and no Ican't use a JMS server product--but maybe a single part of the library. Isaw 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 andsee if there was some cool library that I just didn't know about.
    >
    >
    >
    > Cheers,
    >
    > Me


    Maybe you can tell us what type of project you are working on?

    The above approach sounds like a not-so-great strategy for almost all projects.

    It may be ok for e-mail delivery, but I can't think of anything else where you would want that behavior.

    Thanks.
    bob smith, May 23, 2013
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Joan MacEachern

    [SUN] Achieving High Availability Net Talk

    Joan MacEachern, Sep 29, 2003, in forum: Java
    Replies:
    0
    Views:
    362
    Joan MacEachern
    Sep 29, 2003
  2. Joan MacEachern
    Replies:
    0
    Views:
    359
    Joan MacEachern
    Oct 21, 2003
  3. Elaine
    Replies:
    0
    Views:
    335
    Elaine
    May 10, 2006
  4. Replies:
    1
    Views:
    672
    Phillip Rhodes
    Nov 19, 2006
  5. Alex Wanderleit
    Replies:
    1
    Views:
    848
    Marcel Müller
    Jan 5, 2011
Loading...

Share This Page