javax.websocket.SendHandler Java Examples

@Override
protected void doWrite(SendHandler handler, ByteBuffer... data) {
    long timeout = getSendTimeout();
    if (timeout < 1) {
        timeout = Long.MAX_VALUE;

    }
    SendHandlerToCompletionHandler sh2ch =
            new SendHandlerToCompletionHandler(handler);
    try {
        channel.write(data, 0, data.length, timeout, TimeUnit.MILLISECONDS,
                null, sh2ch);
    } catch (IllegalStateException ise) {
        sh2ch.failed(ise, null);
    }
}
 

@Override
public void sendMessage(Object messageBody, MessageCallback callback) {

    String message;
    try {
        message = mapperProvider.getMapper().writeValueAsString(messageBody);
    } catch (JsonProcessingException e) {
        throw new IllegalArgumentException("Could not convert object to JSON", e);
    }
    session.getAsyncRemote().sendText(message, new SendHandler() {
        @Override
        public void onResult(SendResult sendResult) {
            if (!sendResult.isOK()) {
                callback.failed(SessionBasedAttachedClient.this, sendResult.getException());
            } else {
                callback.successful(SessionBasedAttachedClient.this);
            }
        }
    });
}
 

@Override
public void writeData(ByteBuffer data) {
	if (!this.isConnected()) {
		System.err.println("attempted to write before connection is open.");
		return;
	}
	new Thread(() -> 
	this.dataSession.getAsyncRemote().sendBinary(data, new SendHandler() {
		@Override
		public void onResult(SendResult arg0) {
			RemoteP2PConnection.this.executor.execute(new Runnable() {
				@Override
				public void run() {
					if (RemoteP2PConnection.this.handler != null) RemoteP2PConnection.this.handler.onDataSent(RemoteP2PConnection.this);
				}
			});
		}
	})).start();
}
 

@Override
protected void doWrite(SendHandler handler, ByteBuffer... data) {
    long timeout = getSendTimeout();
    if (timeout < 1) {
        timeout = Long.MAX_VALUE;

    }
    SendHandlerToCompletionHandler sh2ch =
            new SendHandlerToCompletionHandler(handler);
    try {
        channel.write(data, 0, data.length, timeout, TimeUnit.MILLISECONDS,
                null, sh2ch);
    } catch (IllegalStateException ise) {
        sh2ch.failed(ise, null);
    }
}
 

void addMessage(String message) {
    if (messages.size() == count) {
        ((WsSession) session).suspend();
        session.getAsyncRemote().sendText(messages.toString(), new SendHandler() {

            @Override
            public void onResult(SendResult result) {
                ((WsSession) session).resume();
                Assert.assertTrue(result.isOK());
            }
        });
        messages.clear();
    } else {
        messages.add(message);
    }
}
 

private void sendObjectImpl(final Object o, final SendHandler callback) {
    try {
        if (o instanceof String) {
            sendText((String) o, callback);
        } else if (o instanceof byte[]) {
            sendBinary(ByteBuffer.wrap((byte[]) o), callback);
        } else if (o instanceof ByteBuffer) {
            sendBinary((ByteBuffer) o, callback);
        } else if (encoding.canEncodeText(o.getClass())) {
            sendText(encoding.encodeText(o), callback);
        } else if (encoding.canEncodeBinary(o.getClass())) {
            sendBinary(encoding.encodeBinary(o), callback);
        } else {
            // TODO: Replace on bug is fixed
            // https://issues.jboss.org/browse/LOGTOOL-64
            throw new EncodeException(o, "No suitable encoder found");
        }
    } catch (Exception e) {
        callback.onResult(new SendResult(e));
    }
}
 

@Override
public void run() {
    session.getAsyncRemote().sendText("t-" + thread + "-m-" + count.get(), new SendHandler() {
        @Override
        public void onResult(SendResult result) {
            if (!result.isOK()) {
                try {
                    result.getException().printStackTrace();
                    session.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (count.incrementAndGet() != NUM_REQUESTS) {
                executor.submit(SendRunnable.this);
            } else {
                executor.submit(new Runnable() {
                    @Override
                    public void run() {
                        session.getAsyncRemote().sendText("close");
                    }
                });
            }
        }
    });
}
 

public OutputBufferSendHandler(SendHandler completion,
        long blockingWriteTimeoutExpiry,
        ByteBuffer headerBuffer, ByteBuffer payload, byte[] mask,
        ByteBuffer outputBuffer, boolean flushRequired,
        WsRemoteEndpointImplBase endpoint) {
    this.blockingWriteTimeoutExpiry = blockingWriteTimeoutExpiry;
    this.handler = completion;
    this.headerBuffer = headerBuffer;
    this.payload = payload;
    this.mask = mask;
    this.outputBuffer = outputBuffer;
    this.flushRequired = flushRequired;
    this.endpoint = endpoint;
}
 

public TextMessageSendHandler(SendHandler handler, CharBuffer message,
        boolean isLast, CharsetEncoder encoder,
        ByteBuffer encoderBuffer, WsRemoteEndpointImplBase endpoint) {
    this.handler = handler;
    this.message = message;
    this.isLast = isLast;
    this.encoder = encoder.reset();
    this.buffer = encoderBuffer;
    this.endpoint = endpoint;
}
 

void endMessage(SendHandler handler, SendResult result) {
    boolean doWrite = false;
    MessagePart mpNext = null;
    synchronized (messagePartLock) {

        fragmented = nextFragmented;
        text = nextText;

        mpNext = messagePartQueue.poll();
        if (mpNext == null) {
            messagePartInProgress = false;
        } else if (!closed){
            // Session may have been closed unexpectedly in the middle of
            // sending a fragmented message closing the endpoint. If this
            // happens, clearly there is no point trying to send the rest of
            // the message.
            doWrite = true;
        }
    }
    if (doWrite) {
        // Actual write has to be outside sync block to avoid possible
        // deadlock between messagePartLock and writeLock in
        // o.a.coyote.http11.upgrade.AbstractServletOutputStream
        writeMessagePart(mpNext);
    }

    wsSession.updateLastActive();

    // Some handlers, such as the IntermediateMessageHandler, do not have a
    // nested handler so handler may be null.
    if (handler != null) {
        handler.onResult(result);
    }
}
 

public void sendStringByCompletion(String text, SendHandler handler) {
    if (text == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullData"));
    }
    if (handler == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullHandler"));
    }
    stateMachine.textStart();
    TextMessageSendHandler tmsh = new TextMessageSendHandler(handler,
            CharBuffer.wrap(text), true, encoder, encoderBuffer, this);
    tmsh.write();
    // TextMessageSendHandler will update stateMachine when it completes
}
 

public void sendBytesByCompletion(ByteBuffer data, SendHandler handler) {
    if (data == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullData"));
    }
    if (handler == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullHandler"));
    }
    StateUpdateSendHandler sush = new StateUpdateSendHandler(handler);
    stateMachine.binaryStart();
    startMessage(Constants.OPCODE_BINARY, data, true, sush);
}
 

@Override
protected void doWrite(SendHandler handler, ByteBuffer... buffers) {
    this.handler = handler;
    this.buffers = buffers;
    // This is definitely the same thread that triggered the write so a
    // dispatch will be required.
    onWritePossible(true);
}
 

public MessagePart( boolean fin, int rsv, byte opCode, ByteBuffer payload,
        SendHandler intermediateHandler, SendHandler endHandler,
        long blockingWriteTimeoutExpiry) {
    this.fin = fin;
    this.rsv = rsv;
    this.opCode = opCode;
    this.payload = payload;
    this.intermediateHandler = intermediateHandler;
    this.endHandler = endHandler;
    this.blockingWriteTimeoutExpiry = blockingWriteTimeoutExpiry;
}
 

/**
 *
 * @param t             The throwable associated with any error that
 *                      occurred
 * @param useDispatch   Should {@link SendHandler#onResult(SendResult)} be
 *                      called from a new thread, keeping in mind the
 *                      requirements of
 *                      {@link javax.websocket.RemoteEndpoint.Async}
 */
private void clearHandler(Throwable t, boolean useDispatch) {
    // Setting the result marks this (partial) message as
    // complete which means the next one may be sent which
    // could update the value of the handler. Therefore, keep a
    // local copy before signalling the end of the (partial)
    // message.
    SendHandler sh = handler;
    handler = null;
    buffers = null;
    if (sh != null) {
        if (useDispatch) {
            OnResultRunnable r = new OnResultRunnable(sh, t);
            AbstractEndpoint<?> endpoint = socketWrapper.getEndpoint();
            Executor containerExecutor = endpoint.getExecutor();
            if (endpoint.isRunning() && containerExecutor != null) {
                containerExecutor.execute(r);
            } else {
                // Can't use the executor so call the runnable directly.
                // This may not be strictly specification compliant in all
                // cases but during shutdown only close messages are going
                // to be sent so there should not be the issue of nested
                // calls leading to stack overflow as described in bug
                // 55715. The issues with nested calls was the reason for
                // the separate thread requirement in the specification.
                r.run();
            }
        } else {
            if (t == null) {
                sh.onResult(new SendResult());
            } else {
                sh.onResult(new SendResult(t));
            }
        }
    }
}
 

@Override
public void sendObject(final Object data, final SendHandler handler) {

    if (handler == null) {
        throw JsrWebSocketMessages.MESSAGES.handlerIsNull();
    }
    if (data == null) {
        throw JsrWebSocketMessages.MESSAGES.messageInNull();
    }
    sendObjectImpl(data, handler);
}
 

void endMessage(SendHandler handler, SendResult result) {
    boolean doWrite = false;
    MessagePart mpNext = null;
    synchronized (messagePartLock) {

        fragmented = nextFragmented;
        text = nextText;

        mpNext = messagePartQueue.poll();
        if (mpNext == null) {
            messagePartInProgress.release();
        } else if (!closed){
            // Session may have been closed unexpectedly in the middle of
            // sending a fragmented message closing the endpoint. If this
            // happens, clearly there is no point trying to send the rest of
            // the message.
            doWrite = true;
        }
    }
    if (doWrite) {
        // Actual write has to be outside sync block to avoid possible
        // deadlock between messagePartLock and writeLock in
        // o.a.coyote.http11.upgrade.AbstractServletOutputStream
        writeMessagePart(mpNext);
    }

    wsSession.updateLastActive();

    // Some handlers, such as the IntermediateMessageHandler, do not have a
    // nested handler so handler may be null.
    if (handler != null) {
        handler.onResult(result);
    }
}
 

public OutputBufferSendHandler(SendHandler completion,
        ByteBuffer headerBuffer, ByteBuffer payload, byte[] mask,
        ByteBuffer outputBuffer, boolean flushRequired,
        WsRemoteEndpointImplBase endpoint) {
    this.handler = completion;
    this.headerBuffer = headerBuffer;
    this.payload = payload;
    this.mask = mask;
    this.outputBuffer = outputBuffer;
    this.flushRequired = flushRequired;
    this.endpoint = endpoint;
}
 

@Override
public void flush() {
    if (buffer.position() > 0) {
        buffer.flip();
        remote.sendBinary(buffer, new SendHandler() {
            @Override
            public void onResult(SendResult sendResult) {
                if (!sendResult.isOK()) {
                    logger.error("Failed to send messages.", sendResult.getException());
                }
            }
        });
    }
    buffer.clear();
}
 

/**
 *
 * @param t             The throwable associated with any error that
 *                      occurred
 * @param useDispatch   Should {@link SendHandler#onResult(SendResult)} be
 *                      called from a new thread, keeping in mind the
 *                      requirements of
 *                      {@link javax.websocket.RemoteEndpoint.Async}
 */
private void clearHandler(Throwable t, boolean useDispatch) {
    // Setting the result marks this (partial) message as
    // complete which means the next one may be sent which
    // could update the value of the handler. Therefore, keep a
    // local copy before signalling the end of the (partial)
    // message.
    SendHandler sh = handler;
    handler = null;
    buffers = null;
    if (sh != null) {
        if (useDispatch) {
            OnResultRunnable r = onResultRunnables.poll();
            if (r == null) {
                r = new OnResultRunnable(onResultRunnables);
            }
            r.init(sh, t);
            if (executorService == null || executorService.isShutdown()) {
                // Can't use the executor so call the runnable directly.
                // This may not be strictly specification compliant in all
                // cases but during shutdown only close messages are going
                // to be sent so there should not be the issue of nested
                // calls leading to stack overflow as described in bug
                // 55715. The issues with nested calls was the reason for
                // the separate thread requirement in the specification.
                r.run();
            } else {
                executorService.execute(r);
            }
        } else {
            if (t == null) {
                sh.onResult(new SendResult());
            } else {
                sh.onResult(new SendResult(t));
            }
        }
    }
}
 

public MessagePart( boolean fin, int rsv, byte opCode, ByteBuffer payload,
        SendHandler intermediateHandler, SendHandler endHandler) {
    this.fin = fin;
    this.rsv = rsv;
    this.opCode = opCode;
    this.payload = payload;
    this.intermediateHandler = intermediateHandler;
    this.endHandler = endHandler;
}
 

public void sendBytesByCompletion(ByteBuffer data, SendHandler handler) {
    if (data == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullData"));
    }
    if (handler == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullHandler"));
    }
    StateUpdateSendHandler sush = new StateUpdateSendHandler(handler);
    stateMachine.binaryStart();
    startMessage(Constants.OPCODE_BINARY, data, true, sush);
}
 

public void sendStringByCompletion(String text, SendHandler handler) {
    if (text == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullData"));
    }
    if (handler == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullHandler"));
    }
    stateMachine.textStart();
    TextMessageSendHandler tmsh = new TextMessageSendHandler(handler,
            CharBuffer.wrap(text), true, encoder, encoderBuffer, this);
    tmsh.write();
    // TextMessageSendHandler will update stateMachine when it completes
}
 

void endMessage(SendHandler handler, SendResult result) {
    boolean doWrite = false;
    MessagePart mpNext = null;
    synchronized (messagePartLock) {

        fragmented = nextFragmented;
        text = nextText;

        mpNext = messagePartQueue.poll();
        if (mpNext == null) {
            messagePartInProgress = false;
        } else if (!closed){
            // Session may have been closed unexpectedly in the middle of
            // sending a fragmented message closing the endpoint. If this
            // happens, clearly there is no point trying to send the rest of
            // the message.
            doWrite = true;
        }
    }
    if (doWrite) {
        // Actual write has to be outside sync block to avoid possible
        // deadlock between messagePartLock and writeLock in
        // o.a.coyote.http11.upgrade.AbstractServletOutputStream
        writeMessagePart(mpNext);
    }

    wsSession.updateLastActive();

    // Some handlers, such as the IntermediateMessageHandler, do not have a
    // nested handler so handler may be null.
    if (handler != null) {
        handler.onResult(result);
    }
}
 

public TextMessageSendHandler(SendHandler handler, CharBuffer message,
        boolean isLast, CharsetEncoder encoder,
        ByteBuffer encoderBuffer, WsRemoteEndpointImplBase endpoint) {
    this.handler = handler;
    this.message = message;
    this.isLast = isLast;
    this.encoder = encoder.reset();
    this.buffer = encoderBuffer;
    this.endpoint = endpoint;
}
 

public OutputBufferSendHandler(SendHandler completion,
        ByteBuffer headerBuffer, ByteBuffer payload, byte[] mask,
        ByteBuffer outputBuffer, boolean flushRequired,
        WsRemoteEndpointImplBase endpoint) {
    this.handler = completion;
    this.headerBuffer = headerBuffer;
    this.payload = payload;
    this.mask = mask;
    this.outputBuffer = outputBuffer;
    this.flushRequired = flushRequired;
    this.endpoint = endpoint;
}
 

@Override
protected void doWrite(SendHandler handler, ByteBuffer... buffers) {
    this.handler = handler;
    this.buffers = buffers;
    // This is definitely the same thread that triggered the write so a
    // dispatch will be required.
    onWritePossible(true);
}
 

/**
 *
 * @param t             The throwable associated with any error that
 *                      occurred
 * @param useDispatch   Should {@link SendHandler#onResult(SendResult)} be
 *                      called from a new thread, keeping in mind the
 *                      requirements of
 *                      {@link javax.websocket.RemoteEndpoint.Async}
 */
private void clearHandler(Throwable t, boolean useDispatch) {
    // Setting the result marks this (partial) message as
    // complete which means the next one may be sent which
    // could update the value of the handler. Therefore, keep a
    // local copy before signalling the end of the (partial)
    // message.
    SendHandler sh = handler;
    handler = null;
    buffers = null;
    if (sh != null) {
        if (useDispatch) {
            OnResultRunnable r = onResultRunnables.poll();
            if (r == null) {
                r = new OnResultRunnable(onResultRunnables);
            }
            r.init(sh, t);
            if (executorService == null || executorService.isShutdown()) {
                // Can't use the executor so call the runnable directly.
                // This may not be strictly specification compliant in all
                // cases but during shutdown only close messages are going
                // to be sent so there should not be the issue of nested
                // calls leading to stack overflow as described in bug
                // 55715. The issues with nested calls was the reason for
                // the separate thread requirement in the specification.
                r.run();
            } else {
                executorService.execute(r);
            }
        } else {
            if (t == null) {
                sh.onResult(new SendResult());
            } else {
                sh.onResult(new SendResult(t));
            }
        }
    }
}
 

public MessagePart( boolean fin, int rsv, byte opCode, ByteBuffer payload,
        SendHandler intermediateHandler, SendHandler endHandler) {
    this.fin = fin;
    this.rsv = rsv;
    this.opCode = opCode;
    this.payload = payload;
    this.intermediateHandler = intermediateHandler;
    this.endHandler = endHandler;
}
 

public void sendBytesByCompletion(ByteBuffer data, SendHandler handler) {
    if (data == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullData"));
    }
    if (handler == null) {
        throw new IllegalArgumentException(sm.getString("wsRemoteEndpoint.nullHandler"));
    }
    StateUpdateSendHandler sush = new StateUpdateSendHandler(handler, stateMachine);
    stateMachine.binaryStart();
    startMessage(Constants.OPCODE_BINARY, data, true, sush);
}