Interface MessageTransport

public interface MessageTransport

Allows to take over transport of message communication initiated by an instrument. Implement this interface to provide a transport of message communication. When an instrument is about to create a server endpoint, it calls the open(URI, MessageEndpoint) method with the server URI. Usage example:

class RoutedServer implements MessageEndpoint {

    private final MessageEndpoint remoteEndpoint;
    private final OutputStream routerOut = getRouterOutputStream();
    private final WritableByteChannel routerOutChannel;

    RoutedServer(MessageEndpoint remoteEndpoint) {
        this.remoteEndpoint = remoteEndpoint;
        this.routerOutChannel = Channels.newChannel(routerOut);
        new Thread(() -> {
            try {
                runInputLoop();
            } catch (IOException ex) {
            }
        }).start();
    }

    @Override
    public void sendText(String text) throws IOException {
        routerOut.write(text.getBytes());
        routerOut.flush();
    }

    @Override
    public void sendBinary(ByteBuffer data) throws IOException {
        routerOutChannel.write(data);
        routerOut.flush();
    }

    @Override
    public void sendPing(ByteBuffer data) throws IOException {
        remoteEndpoint.sendPong(data);
    }

    @Override
    public void sendPong(ByteBuffer data) throws IOException {
        // Did we send ping?
    }

    @Override
    public void sendClose() throws IOException {
        routerOut.close();
    }

    private void runInputLoop() throws IOException {
        try (InputStream routerIn = getRouterInputStream()) {
            byte[] buf = new byte[1024];
            ByteBuffer bb = ByteBuffer.wrap(buf);
            int l;
            while ((l = routerIn.read(buf)) > 0) {
                bb.limit(l);
                remoteEndpoint.sendBinary(bb);
                bb.rewind();
            }
        } finally {
            remoteEndpoint.sendClose();
        }
    }
}

Engine.newBuilder().serverTransport(
                (uri, peerEndpoint) -> {
                    if (denyHost.equals(uri.getHost())) {
                        throw new MessageTransport.VetoException("Denied access.");
                    } else if (routedURI.equals(uri)) {
                        return new RoutedServer(peerEndpoint);
                    } else {
                        // Permit instruments to setup the servers themselves
                        return null;
                    }
                }).build();

Since:

19.0

See Also:

• Engine.Builder.serverTransport(MessageTransport)
• Context.Builder.serverTransport(MessageTransport)

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	MessageTransport.VetoException	Thrown when a transport connection is vetoed.

Method Summary

Modifier and Type	Method	Description
MessageEndpoint	open(URI uri, MessageEndpoint peerEndpoint)	Called when a connection to an URI is to be established.

Method Details

open

MessageEndpoint open(URI uri,
 MessageEndpoint peerEndpoint)
              throws IOException,
MessageTransport.VetoException

Called when a connection to an URI is to be established. The virtualized connection is either opened and an endpoint call back is returned, or the connection is not virtualized in which case null is returned.

This method can be called concurrently from multiple threads. However, the MessageEndpoint ought to be called on one thread at a time, unless you're sure that the particular implementation can handle concurrent calls. The same holds true for the returned endpoint, it's called synchronously.

Parameters:

uri - the connection URI

peerEndpoint - the peer endpoint representation

Returns:

an implementation of MessageEndpoint call back, or null.

Throws:

MessageTransport.VetoException - to veto connection to the URL.

IOException

Since:

19.0