com.paritytrading.nassau.soupbintcp.SoupBinTCPClient Java Examples

private static void receive(SoupBinTCPClient client) throws IOException {
    try (Selector selector = Selector.open()) {

        client.getChannel().register(selector, SelectionKey.OP_READ);

        while (receive) {
            int numKeys = selector.select(TIMEOUT_MILLIS);
            if (numKeys > 0) {
                if (client.receive() < 0)
                    break;

                selector.selectedKeys().clear();
            }

            client.keepAlive();
        }
    }
}
 

private static void main(Config config, File file) throws IOException {
    addShutdownHook();

    try (final BinaryFILEWriter writer = BinaryFILEWriter.open(file)) {

        MessageListener listener = new MessageListener() {

            @Override
            public void message(ByteBuffer buffer) throws IOException {
                writer.write(buffer);
            }

        };

        if (config.hasPath("session.multicast-interface")) {
            try (MoldUDP64Client client = join(config, listener)) {
                receive(client);
            }
        } else {
            try (SoupBinTCPClient client = connect(config, listener)) {
                receive(client);
            }
        }
    }
}
 

public static OrderEntry open(InetSocketAddress address) throws IOException {
    SocketChannel channel = SocketChannel.open();

    channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
    channel.connect(address);
    channel.configureBlocking(false);

    MessageListener listener = new POEClientParser(new Listener());

    SoupBinTCPClient transport = new SoupBinTCPClient(channel, POE.MAX_OUTBOUND_MESSAGE_LENGTH,
            listener, new StatusListener());

    return new OrderEntry(transport);
}
 

SoupBinTCPClient create(POEClientListener listener,
        SoupBinTCPClientStatusListener statusListener) throws IOException {
    SocketChannel channel = SocketChannel.open();

    channel.connect(address);

    channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
    channel.configureBlocking(false);

    return new SoupBinTCPClient(channel, POE.MAX_OUTBOUND_MESSAGE_LENGTH,
            new POEClientParser(listener), statusListener);
}
 

@Override
public void loginRejected(SoupBinTCPClient session, SoupBinTCP.LoginRejected payload) throws IOException {
    switch (payload.rejectReasonCode) {
    case SoupBinTCP.LOGIN_REJECT_CODE_NOT_AUTHORIZED:
        fix.sendLogout("Not authorized");
        break;
    case SoupBinTCP.LOGIN_REJECT_CODE_SESSION_NOT_AVAILABLE:
        fix.sendLogout("Session not available");
        break;
    }
}
 

/**
 * Receive messages. Invoke the message listener on each message. Continue
 * until an End of Session packet is received or the end-of-stream is
 * reached.
 *
 * @param address the address
 * @param username the username
 * @param password the password
 * @param listener a message listener
 * @throws IOException if an I/O error occurs
 */
public static void receive(InetSocketAddress address, String username,
        String password, MessageListener listener) throws IOException {
    SocketChannel channel = SocketChannel.open();

    channel.connect(address);
    channel.configureBlocking(false);

    StatusListener statusListener = new StatusListener();

    try (Selector selector = Selector.open();
            SoupBinTCPClient client = new SoupBinTCPClient(channel, listener, statusListener)) {
        channel.register(selector, SelectionKey.OP_READ);

        LoginRequest message = new LoginRequest();

        message.setUsername(username);
        message.setPassword(password);
        message.setRequestedSession("");
        message.setRequestedSequenceNumber(1);

        client.login(message);

        while (statusListener.receive) {
            int numKeys = selector.select(TIMEOUT_MILLIS);

            if (numKeys > 0) {
                if (client.receive() < 0)
                    break;

                selector.selectedKeys().clear();
            }

            client.keepAlive();
        }
    }
}
 

@Override
public void heartbeatTimeout(SoupBinTCPClient session) {
    close();
}
 

private OrderEntry(SoupBinTCPClient transport) {
    this.transport = transport;

    this.txBuffer = ByteBuffer.allocateDirect(POE.MAX_INBOUND_MESSAGE_LENGTH);
}
 

@Override
public void endOfSession(SoupBinTCPClient session) throws IOException {
    fix.sendLogout();
}
 

public SoupBinTCPClient getTransport() {
    return transport;
}
 

@Override
public void loginAccepted(SoupBinTCPClient session, SoupBinTCP.LoginAccepted payload) throws IOException {
    fix.sendLogon(false);
}
 

@Override
public void heartbeatTimeout(SoupBinTCPClient session) throws IOException {
    fix.sendLogout("Trading system not available");
}
 

SoupBinTCPClient getOrderEntry() {
    return orderEntry;
}
 

@Override
public void endOfSession(SoupBinTCPClient session) {
}
 

@Override
public void loginRejected(SoupBinTCPClient session, SoupBinTCP.LoginRejected payload) {
    close();
}
 

@Override
public void loginAccepted(SoupBinTCPClient session, SoupBinTCP.LoginAccepted payload) {
}
 

@Override
public void loginRejected(SoupBinTCPClient session, SoupBinTCP.LoginRejected payload) {
    error("Login rejected");
}
 

SoupBinTCPClient getTransport() {
    return transport;
}
 

private OrderEntry(Selector selector, SocketChannel channel, POEClientListener listener) {
    this.txBuffer = ByteBuffer.allocateDirect(POE.MAX_INBOUND_MESSAGE_LENGTH);

    this.selector = selector;

    this.transport = new SoupBinTCPClient(channel, POE.MAX_OUTBOUND_MESSAGE_LENGTH,
            new POEClientParser(listener), new StatusListener());

    this.closed = false;

    this.txLock = new Object();

    Thread receiver = new Thread(new Receiver());

    receiver.setDaemon(true);
    receiver.start();
}
 

@Override
public void endOfSession(SoupBinTCPClient session) {
    receive = false;
}
 

@Override
public void loginRejected(SoupBinTCPClient session, LoginRejected payload) throws IOException {
    throw new IOException("Login rejected");
}
 

@Override
public void loginAccepted(SoupBinTCPClient session, LoginAccepted payload) {
}
 

@Override
public void heartbeatTimeout(SoupBinTCPClient session) throws IOException {
    throw new IOException("Heartbeat timeout");
}
 

@Override
public void heartbeatTimeout(SoupBinTCPClient session) {
    error("Heartbeat timeout");
}
 

@Override
public void endOfSession(SoupBinTCPClient session) {
}
 

@Override
public void loginAccepted(SoupBinTCPClient session, SoupBinTCP.LoginAccepted payload) {
}