java.nio.channels.ByteChannel Java Examples

@Override
public void createSocketOnOutgoingConnection(final InetSocketAddress socketAddress, final SocketEstablishedCallback socketEstablishedCallback)
{
    final ByteChannel byteChannel = createByteChannel(readableByteChannel, writableByteChannel);
    executorService.submit(new Runnable()
    {
        @Override
        public void run()
        {
            try
            {
                socketEstablishedCallback.onSocketEstablished(new StubSocketChannel(byteChannel));
            }
            catch (RuntimeException e)
            {
                System.err.println("Exception thrown: ");
                e.printStackTrace(System.err);
            }
        }
    });
}
 

public ChannelEndPoint(ByteChannel channel) throws IOException
{
    super();
    this._channel = channel;
    _socket=(channel instanceof SocketChannel)?((SocketChannel)channel).socket():null;
    if (_socket!=null)
    {
        _local=(InetSocketAddress)_socket.getLocalSocketAddress();
        _remote=(InetSocketAddress)_socket.getRemoteSocketAddress();
        _maxIdleTime=_socket.getSoTimeout();
    }
    else
    {
        _local=_remote=null;
    }
}
 

/**
 * ByteChannelからint配列を読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static int[] readIntArray(@NonNull final ByteChannel channel)
	throws IOException {
	
	final int n = readInt(channel);
	final ByteBuffer buf = ByteBuffer.allocate(n * 4).order(ByteOrder.BIG_ENDIAN);
	final int readBytes = channel.read(buf);
	if (readBytes != n * 4) throw new IOException();
	buf.clear();
	final IntBuffer result = buf.asIntBuffer();
	if (result.hasArray()) {
		return result.array();
	}  else {
		final int[] b = new int[n];
		result.get(b);
		return b;
	}
}
 

/**
 * ByteChannelからchar配列を読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static char[] readCharArray(@NonNull final ByteChannel channel)
	throws IOException {
	
	final int n = readInt(channel);
	final ByteBuffer buf = ByteBuffer.allocate(n * 2).order(ByteOrder.BIG_ENDIAN);
	final int readBytes = channel.read(buf);
	if (readBytes != n * 2) throw new IOException();
	buf.clear();
	final CharBuffer result = buf.asCharBuffer();
	if (result.hasArray()) {
		return result.array();
	}  else {
		final char[] b = new char[n];
		result.get(b);
		return b;
	}
}
 

protected ChannelEndPoint(ByteChannel channel, int maxIdleTime) throws IOException
{
    this._channel = channel;
    _maxIdleTime=maxIdleTime;
    _socket=(channel instanceof SocketChannel)?((SocketChannel)channel).socket():null;
    if (_socket!=null)
    {
        _local=(InetSocketAddress)_socket.getLocalSocketAddress();
        _remote=(InetSocketAddress)_socket.getRemoteSocketAddress();
        _socket.setSoTimeout(_maxIdleTime);
    }
    else
    {
        _local=_remote=null;
    }
}
 

public boolean cancel(boolean mayInterruptIfRunning)
{
    try
    {
        ByteChannel channel=null;
        synchronized (this)
        {
            if (_connection==null && _exception==null && _channel!=null)
            {
                channel=_channel;
                _channel=null;
            }
        }

        if (channel!=null)
        {
            closeChannel(channel,WebSocketConnectionRFC6455.CLOSE_NO_CLOSE,"cancelled");
            return true;
        }
        return false;
    }
    finally
    {
        _done.countDown();
    }
}
 

@Override
public ByteChannel wrapChannel(SocketChannel channel, SelectionKey key) throws IOException {
    SSLEngine e = sslcontext.createSSLEngine();
    /*
     * See https://github.com/TooTallNate/Java-WebSocket/issues/466
     *
     * We remove TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 from the enabled ciphers since it is
     * just available when you patch your java installation directly.
     * E.g. firefox requests this cipher and this causes some dcs/instable connections
     */
    List<String> ciphers = new ArrayList<String>(Arrays.asList(e.getEnabledCipherSuites()));
    ciphers.remove("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256");
    e.setEnabledCipherSuites(ciphers.toArray(new String[ciphers.size()]));
    e.setUseClientMode(false);
    return new SSLSocketChannel2(channel, e, exec, key);
}
 

public boolean cancel(boolean mayInterruptIfRunning)
{
    try
    {
        ByteChannel channel=null;
        synchronized (this)
        {
            if (_connection==null && _exception==null && _channel!=null)
            {
                channel=_channel;
                _channel=null;
            }
        }

        if (channel!=null)
        {
            closeChannel(channel,WebSocketConnectionRFC6455.CLOSE_NO_CLOSE,"cancelled");
            return true;
        }
        return false;
    }
    finally
    {
        _done.countDown();
    }
}
 

@Override
protected int read(ByteChannel src, ByteBuf dst) throws IOException {
    if (src instanceof ScatteringByteChannel) {
        return dst.writeBytes((ScatteringByteChannel) src, dst.writableBytes());
    }

    final int readBytes = src.read(dst.nioBuffer(dst.writerIndex(), dst.writableBytes()));
    if (readBytes > 0) {
        dst.writerIndex(dst.writerIndex() + readBytes);
    }
    return readBytes;
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	final short value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 2);
	buf.putShort(value);
	buf.flip();
	channel.write(buf);
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	@NonNull final double[] value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final int n = value.length;
	write(channel, n, work);
	final ByteBuffer buf = checkBuffer(work, n * 8);
	for (int i = 0; i < n; i++) {
		buf.putDouble(value[i]);
	}
	buf.flip();
	channel.write(buf);
}
 

/** Returns whether the whole outQueue has been flushed
 * @param ws The WebSocketImpl associated with the channels
 * @param sockchannel The channel to write to
 * @throws IOException May be thrown by {@link WrappedByteChannel#writeMore()}
 * @return returns Whether there is more data to write
 */
public static boolean batch(WebSocketImpl ws, ByteChannel sockchannel) throws IOException {
    ByteBuffer buffer = ws.outQueue.peek();
    WrappedByteChannel c = null;

    if (buffer == null) {
        if (sockchannel instanceof WrappedByteChannel) {
            c = (WrappedByteChannel) sockchannel;
            if (c.isNeedWrite()) {
                c.writeMore();
            }
        }
    } else {
        do {// FIXME writing as much as possible is unfair!!
            /*int written = */
            sockchannel.write(buffer);
            if (buffer.remaining() > 0) {
                return false;
            } else {
                ws.outQueue.poll(); // Buffer finished. Remove it.
                buffer = ws.outQueue.peek();
            }
        } while (buffer != null);
    }

    if (ws != null && ws.outQueue.isEmpty() && ws.isFlushAndClose() && ws.getDraft() != null && ws.getDraft().getRole() != null && ws.getDraft().getRole() == Role.SERVER) {//
        synchronized (ws) {
            ws.closeConnection();
        }
    }
    return c == null || !((WrappedByteChannel) sockchannel).isNeedWrite();
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	final float value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 4);
	buf.putFloat(value);
	buf.flip();
	channel.write(buf);
}
 

/** Returns whether the whole outQueue has been flushed
 * @param ws The WebSocketImpl associated with the channels
 * @param sockchannel The channel to write to
 * @throws IOException May be thrown by {@link WrappedByteChannel#writeMore()}
 * @return returns Whether there is more data to write
 */
public static boolean batch( WebSocketImpl ws, ByteChannel sockchannel ) throws IOException {
	ByteBuffer buffer = ws.outQueue.peek();
	WrappedByteChannel c = null;

	if( buffer == null ) {
		if( sockchannel instanceof WrappedByteChannel ) {
			c = (WrappedByteChannel) sockchannel;
			if( c.isNeedWrite() ) {
				c.writeMore();
			}
		}
	} else {
		do {// FIXME writing as much as possible is unfair!!
			/*int written = */sockchannel.write( buffer );
			if( buffer.remaining() > 0 ) {
				return false;
			} else {
				ws.outQueue.poll(); // Buffer finished. Remove it.
				buffer = ws.outQueue.peek();
			}
		} while ( buffer != null );
	}

	if( ws != null && ws.outQueue.isEmpty() && ws.isFlushAndClose() && ws.getDraft() != null && ws.getDraft().getRole() != null && ws.getDraft().getRole() == Role.SERVER ) {//
		synchronized ( ws ) {
			ws.closeConnection();
		}
	}
	return c == null || !((WrappedByteChannel) sockchannel).isNeedWrite();
}
 

/**
 * Loads the data from a previous flush into the buffer if it hasn't been loaded already.
 */
private void ensureLoaded()
        throws IOException {
    if (!_loaded) {
        if (_backingFile != null) {
            _log.debug("Loading buffer for index {} from {}", _startIndex, _backingFile);
            try (ByteChannel in = Files.newByteChannel(_backingFile, READ)) {
                in.read(_buffer);
            }
        }
        _loaded = true;
    }
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	@NonNull final boolean[] value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final int n = value.length;
	write(channel, n, work);
	final ByteBuffer buf = checkBuffer(work, n);
	for (int i = 0; i < n; i++) {
		buf.put((byte)(value[i] ? 1 : 0));
	}
	buf.flip();
	channel.write(buf);
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	@NonNull final byte[] value) throws IOException {
	
	write(channel, value.length);
	channel.write(ByteBuffer.wrap(value));
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	@NonNull final char[] value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final int n = value.length;
	write(channel, n, work);
	final ByteBuffer buf = checkBuffer(work, n * 2);
	for (int i = 0; i < n; i++) {
		buf.putChar(value[i]);
	}
	buf.flip();
	channel.write(buf);
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	final char value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 2);
	buf.putChar(value);
	buf.flip();
	channel.write(buf);
}
 

/**
 * ByteChannelへ書き込む
 * @param channel
 * @param value
 * @param work
 * @throws IOException
 */
public static void write(@NonNull final ByteChannel channel,
	@NonNull final short[] value,
	@Nullable final ByteBuffer work) throws IOException {
	
	final int n = value.length;
	write(channel, n, work);
	final ByteBuffer buf = checkBuffer(work, n * 2);
	for (int i = 0; i < n; i++) {
		buf.putShort(value[i]);
	}
	buf.flip();
	channel.write(buf);
}
 

public void handshakeFailed(Throwable ex)
{
    try
    {
        ByteChannel channel=null;
        synchronized (this)
        {
            if (_channel!=null)
            {
                channel=_channel;
                _channel=null;
                _exception=ex;
            }
        }

        if (channel!=null)
        {
            if (ex instanceof ProtocolException)
                closeChannel(channel,WebSocketConnectionRFC6455.CLOSE_PROTOCOL,ex.getMessage());
            else
                closeChannel(channel,WebSocketConnectionRFC6455.CLOSE_NO_CLOSE,ex.getMessage());
        }
    }
    finally
    {
        _done.countDown();
    }
}
 

/**
 * ByteChannelからbyte配列を読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static byte[] readByteArray(@NonNull final ByteChannel channel)
	throws IOException {
	
	final int n = readInt(channel);
	final byte[] result = new byte[n];
	final ByteBuffer buf = ByteBuffer.wrap(result);
	final int readBytes = channel.read(buf);
	if (readBytes != n) throw new IOException();
	return result;
}
 

/**
 * ByteChannelからStringを読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static String readString(@NonNull final ByteChannel channel)
	throws IOException {
	
	final int bytes = readInt(channel);
	final byte[] buf = new byte[bytes];
	final ByteBuffer b = ByteBuffer.wrap(buf);
	final int readBytes = channel.read(b);
	if (readBytes != bytes) throw new IOException();
	return new String(buf, CharsetsUtils.UTF8);
}
 

/**
 * ByteChannelからdoubleを読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static double readDouble(@NonNull final ByteChannel channel,
	@Nullable final ByteBuffer work) throws IOException {

	final ByteBuffer buf = checkBuffer(work, 8);
	final int readBytes = channel.read(buf);
	if (readBytes != 8) throw new IOException();
	buf.clear();
	return buf.getDouble();
}
 

private ClientTlsChannel(
    ByteChannel underlying,
    SSLEngine engine,
    Consumer<SSLSession> sessionInitCallback,
    boolean runTasks,
    BufferAllocator plainBufAllocator,
    BufferAllocator encryptedBufAllocator,
    boolean releaseBuffers,
    boolean waitForCloseNotifyOnClose) {
  if (!engine.getUseClientMode())
    throw new IllegalArgumentException("SSLEngine must be in client mode");
  this.underlying = underlying;
  TrackingAllocator trackingPlainBufAllocator = new TrackingAllocator(plainBufAllocator);
  TrackingAllocator trackingEncryptedAllocator = new TrackingAllocator(encryptedBufAllocator);
  impl =
      new TlsChannelImpl(
          underlying,
          underlying,
          engine,
          Optional.empty(),
          sessionInitCallback,
          runTasks,
          trackingPlainBufAllocator,
          trackingEncryptedAllocator,
          releaseBuffers,
          waitForCloseNotifyOnClose);
}
 

/**
 * ByteChannelからfloatを読み込む
 * @param channel
 * @return
 * @throws IOException
 */
public static float readFloat(@NonNull final ByteChannel channel,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 4);
	final int readBytes = channel.read(buf);
	if (readBytes != 4) throw new IOException();
	buf.clear();
	return buf.getFloat();
}
 

/**
 * ByteChannelからlongを読み込む
 * @param channel
 * @param work
 * @return
 * @throws IOException
 */
public static long readLong(@NonNull final ByteChannel channel,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 8);
	final int readBytes = channel.read(buf);
	if (readBytes != 8) throw new IOException();
	buf.clear();
	return buf.getLong();
}
 

private WebSocketFuture(WebSocket websocket, URI uri, WebSocketClient client, ByteChannel channel)
{
    _websocket=websocket;
    _uri=uri;
    _client=client;
    _channel=channel;
}
 

/**
 * ByteChannelからintを読み込む
 * @param channel
 * @param work
 * @return
 * @throws IOException
 */
public static int readInt(@NonNull final ByteChannel channel,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 4);
	final int readBytes = channel.read(buf);
	if (readBytes != 4) throw new IOException();
	buf.clear();
	return buf.getInt();
}
 

/**
 * ByteChannelからcharを読み込む
 * @param channel
 * @param work
 * @return
 * @throws IOException
 */
public static char readChar(@NonNull final ByteChannel channel,
	@Nullable final ByteBuffer work) throws IOException {
	
	final ByteBuffer buf = checkBuffer(work, 2);
	final int readBytes = channel.read(buf);
	if (readBytes != 2) throw new IOException();
	buf.clear();
	return buf.getChar();
}