Java Code Examples for java.nio.channels.SocketChannel#setOption()

/**
 * Initialize the SocketStream with a new Socket.
 *
 * @param s the new socket.
 */
public void init(SocketChannel s)
{
  _s = s;

  try {
    s.setOption(StandardSocketOptions.TCP_NODELAY, true);
  } catch (Exception e) {
    e.printStackTrace();;
  }
  //_is = null;
  //_os = null;
  _needsFlush = false;
  
  _readBuffer.clear().flip();
  _writeBuffer.clear();
}
 

void setupSocketChannel(SocketChannel socketChannel) throws IOException {
    socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, keepAlive);
    socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, tcpNoDelay);

    if (rcvBufferSize > 0) {
        socketChannel.setOption(StandardSocketOptions.SO_RCVBUF, rcvBufferSize);
    }

    if (sndBufferSize > 0) {
        socketChannel.setOption(StandardSocketOptions.SO_SNDBUF, sndBufferSize);
    }

    if (lingerMs >= 0) {
        socketChannel.setOption(StandardSocketOptions.SO_LINGER, lingerMs);
    }
}
 

public void setSocketParams(ClosableConnection con, boolean isFrontChannel) throws IOException {
	int sorcvbuf = 0;
    int sosndbuf = 0;
    int soNoDelay = 0;
    
	if (isFrontChannel) {
		sorcvbuf = this.netConfig.getFrontsocketsorcvbuf();
		sosndbuf = this.netConfig.getFrontsocketsosndbuf();
		soNoDelay = this.netConfig.getFrontSocketNoDelay();
	} else {
		sorcvbuf = this.netConfig.getBacksocketsorcvbuf();
		sosndbuf = this.netConfig.getBacksocketsosndbuf();
		soNoDelay = this.netConfig.getBackSocketNoDelay();
	}
	
	SocketChannel socketChannel = con.getSocketChannel();
	socketChannel.setOption(StandardSocketOptions.SO_RCVBUF, sorcvbuf);
	socketChannel.setOption(StandardSocketOptions.SO_SNDBUF, sosndbuf);
	socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, soNoDelay == 1);
    socketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
}
 

@Override
public void run() {
    try {
        for (;;) {
            SocketChannel channel = this.serverChannel.accept();
            channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
            Orca orca = this.fish.getOrca();
            if (orca == null) {
                channel.close();
                continue;
            }
            if (orca.isClosed()) {
                channel.close();
                continue;
            }
            this.pool.execute(new SimpleSocketWorker(this.fish, channel));
        }
    }
    catch (AsynchronousCloseException ignored) {}
    catch (Exception x) {
        _log.warn("", x);
    }
}
 

Session accept() {
    try {
        SocketChannel fix = serverChannel.accept();
        if (fix == null)
            return null;

        try {
            fix.setOption(StandardSocketOptions.TCP_NODELAY, true);
            fix.configureBlocking(false);

            return new Session(orderEntry, fix, config, instruments);
        } catch (IOException e1) {
            fix.close();

            return null;
        }
    } catch (IOException e2) {
        return null;
    }
}
 

public void test_setOption() throws Exception {
    SocketChannel sc = SocketChannel.open();
    sc.setOption(StandardSocketOptions.SO_LINGER, 1000);

    // Assert that we can read back the option from the channel...
    assertEquals(1000, (int) sc.<Integer>getOption(StandardSocketOptions.SO_LINGER));
    // ... and its socket adaptor.
    assertEquals(1000, sc.socket().getSoLinger());

    sc.close();
    try {
        sc.setOption(StandardSocketOptions.SO_LINGER, 2000);
        fail();
    } catch (ClosedChannelException expected) {
    }
}
 

public void applySettings(@NotNull SocketChannel channel) throws IOException {
	if (sendBufferSize != 0) {
		channel.setOption(SO_SNDBUF, sendBufferSize);
	}
	if (receiveBufferSize != 0) {
		channel.setOption(SO_RCVBUF, receiveBufferSize);
	}
	if (keepAlive != DEF_BOOL) {
		channel.setOption(SO_KEEPALIVE, keepAlive != FALSE);
	}
	if (reuseAddress != DEF_BOOL) {
		channel.setOption(SO_REUSEADDR, reuseAddress != FALSE);
	}
	if (tcpNoDelay != DEF_BOOL) {
		channel.setOption(TCP_NODELAY, tcpNoDelay != FALSE);
	}
}
 

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

public Session accept() throws IOException {
    SocketChannel channel = serverChannel.accept();
    channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
    channel.configureBlocking(false);

    return new Session(channel);
}
 

private static TestClient connect(SocketAddress address) throws IOException {
    SocketChannel channel = SocketChannel.open();

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

    return new TestClient(channel);
}
 

public Session accept() throws IOException {
    SocketChannel downstream = serverChannel.accept();
    if (downstream == null)
        return null;

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

    return new Session(upstream, downstream);
}
 

private void accept(SelectionKey key) throws IOException {
    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

    SocketChannel socketChannel = serverSocketChannel.accept();
    socketChannel.configureBlocking(false);
    socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
    socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);
    socketChannel.register(selector, SelectionKey.OP_READ);

    System.out.println("Client is connected");
}
 

private void testClient() throws IOException {

        SocketChannel sc = TCPRegistry.createSocketChannel(serverHostPort);
        sc.setOption(StandardSocketOptions.SO_REUSEADDR, true);
        sc.configureBlocking(false);

        //       testThroughput(sc);
        testLatency(serverHostPort, WireType.BINARY, sc);

        TcpChannelHub.closeAllHubs();
        TCPRegistry.reset();
    }
 

static Initiator open(SocketAddress address) throws IOException {
    SocketChannel channel = SocketChannel.open();

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

    return new Initiator(channel);
}
 

Session accept() throws IOException {
    SocketChannel channel = serverChannel.accept();

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

    return new Session(channel);
}
 

private void configure(final SocketChannel channel) throws IOException
{
    channel.setOption(TCP_NODELAY, true);
    if (configuration.receiverSocketBufferSize() > 0)
    {
        channel.setOption(SO_RCVBUF, configuration.receiverSocketBufferSize());
    }
    if (configuration.senderSocketBufferSize() > 0)
    {
        channel.setOption(SO_SNDBUF, configuration.senderSocketBufferSize());
    }
}
 

protected SocketChannel open() throws IOException
{
    final SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
    socketChannel.configureBlocking(false);
    socketChannel.setOption(TCP_NODELAY, true);
    socketChannel.setOption(SO_RCVBUF, 1024 * 1024);
    socketChannel.setOption(SO_RCVBUF, 1024 * 1024);
    return socketChannel;
}
 

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

@SuppressWarnings("unchecked")
public Connection make(SocketChannel channel) throws IOException {
	channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	// 子类完成具体连接创建工作
	Connection c = makeConnection(channel);
	// 设置连接的参数
	NetSystem.getInstance().setSocketParams(c,true);
	// 设置NIOHandler
	c.setHandler(getNIOHandler());
	return c;
}
 

/**
 * Processes an OP_ACCEPT selection event
 *
 * We will accept the connection if we haven't reached the maximum number of
 * connections. The new socket channel will be placed in non-blocking mode
 * and the selection key enabled for read events. We will not add the peer
 * address to the peer address list since we only want nodes that have
 * advertised their availability on the list.
 */
private void processAccept(SelectionKey acceptKey) {
	try {
		SocketChannel channel = listenChannel.accept();
		if (channel != null) {
			InetSocketAddress remoteAddress = (InetSocketAddress) channel.getRemoteAddress();
			PeerAddress address = new PeerAddress(remoteAddress);
			if (connections.size() >= maxConnections) {
				channel.close();
				BTCLoader.info(String.format("Max connections reached: Connection rejected from %s", address));
			} else if (isBlacklisted(address.getAddress())) {
				channel.close();
				BTCLoader.info(String.format("Connection rejected from banned address %s", address));
			} else if (connectionMap.get(address.getAddress()) != null) {
				channel.close();
				BTCLoader.info(String.format("Duplicate connection rejected from %s", address));
			} else {
				address.setTimeConnected(System.currentTimeMillis() / 1000);
				channel.configureBlocking(false);
				channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
				SelectionKey key = channel.register(networkSelector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
				Peer peer = new Peer(address, channel, key);
				key.attach(peer);
				peer.setConnected(true);
				address.setConnected(true);
				BTCLoader.info(String.format("Connection accepted from %s", address));
				Message msg = VersionMessage.buildVersionMessage(peer, BTCLoader.listenAddress,
						BTCLoader.blockStore.getChainHeight());
				synchronized (connections) {
					connections.add(peer);
					connectionMap.put(address.getAddress(), peer);
					peer.getOutputList().add(msg);
				}
				BTCLoader.info(String.format("Sent 'version' message to %s", address));
			}
		}
	} catch (IOException exc) {
		BTCLoader.error("Unable to accept connection", exc);
		networkShutdown = true;
	}
}