private DataBuffer toDataBuffer(String body, Charset charset) { byte[] bytes = body.getBytes(charset); ByteBuffer byteBuffer = ByteBuffer.wrap(bytes); return this.bufferFactory.wrap(byteBuffer); }
@Override public DataBuffer wrap(byte[] bytes) { return this.delegate.wrap(bytes); }
@Override public DataBuffer wrap(ByteBuffer byteBuffer) { return this.delegate.wrap(byteBuffer); }
@Override public WebSocketMessage textMessage(String payload) { byte[] bytes = payload.getBytes(StandardCharsets.UTF_8); DataBuffer buffer = bufferFactory().wrap(bytes); return new WebSocketMessage(WebSocketMessage.Type.TEXT, buffer); }
@Override public ServerRequest.Builder body(String body) { Assert.notNull(body, "Body must not be null"); releaseBody(); DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory(); this.body = Flux.just(body). map(s -> { byte[] bytes = body.getBytes(StandardCharsets.UTF_8); return dataBufferFactory.wrap(bytes); }); return this; }
@Override public ClientResponse.Builder body(String body) { Assert.notNull(body, "Body must not be null"); releaseBody(); DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory(); this.body = Flux.just(body). map(s -> { byte[] bytes = body.getBytes(StandardCharsets.UTF_8); return dataBufferFactory.wrap(bytes); }); return this; }
private Mono<?> decodeData(String data, ResolvableType dataType, Map<String, Object> hints) { if (String.class == dataType.resolve()) { return Mono.just(data.substring(0, data.length() - 1)); } if (this.decoder == null) { return Mono.error(new CodecException("No SSE decoder configured and the data is not String.")); } byte[] bytes = data.getBytes(StandardCharsets.UTF_8); Mono<DataBuffer> input = Mono.just(bufferFactory.wrap(bytes)); return this.decoder.decodeToMono(input, dataType, MediaType.TEXT_EVENT_STREAM, hints); }
@Override public Flux<DataBuffer> encode(Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { return Flux.from(inputStream).map(bytes -> { DataBuffer dataBuffer = bufferFactory.wrap(bytes); if (logger.isDebugEnabled() && !Hints.isLoggingSuppressed(hints)) { String logPrefix = Hints.getLogPrefix(hints); logger.debug(logPrefix + "Writing " + dataBuffer.readableByteCount() + " bytes"); } return dataBuffer; }); }
@Override public Flux<DataBuffer> encode(Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { return Flux.from(inputStream).map(byteBuffer -> { DataBuffer dataBuffer = bufferFactory.wrap(byteBuffer); if (logger.isDebugEnabled() && !Hints.isLoggingSuppressed(hints)) { String logPrefix = Hints.getLogPrefix(hints); logger.debug(logPrefix + "Writing " + dataBuffer.readableByteCount() + " bytes"); } return dataBuffer; }); }
private DataBuffer toDataBuffer(String body, Charset charset) { byte[] bytes = body.getBytes(charset); ByteBuffer byteBuffer = ByteBuffer.wrap(bytes); return this.bufferFactory.wrap(byteBuffer); }
@Override public MockServerHttpRequest body(String body) { return body(Flux.just(BUFFER_FACTORY.wrap(body.getBytes(getCharset())))); }
private <T> WebSocketMessage toMessage(T message) { WebSocketSession session = this.delegateSession; Assert.state(session != null, "Cannot create message without a session"); if (message instanceof String) { byte[] bytes = ((String) message).getBytes(StandardCharsets.UTF_8); return new WebSocketMessage(Type.TEXT, session.bufferFactory().wrap(bytes)); } else if (message instanceof ByteBuffer) { DataBuffer buffer = session.bufferFactory().wrap((ByteBuffer) message); return new WebSocketMessage(Type.BINARY, buffer); } else if (message instanceof PongMessage) { DataBuffer buffer = session.bufferFactory().wrap(((PongMessage) message).getApplicationData()); return new WebSocketMessage(Type.PONG, buffer); } else { throw new IllegalArgumentException("Unexpected message type: " + message); } }
private DataBuffer wrap(String value, ServerHttpResponse response) { byte[] bytes = value.getBytes(StandardCharsets.UTF_8); return response.bufferFactory().wrap(bytes); } }
private <T> WebSocketMessage toMessage(Type type, T message) { WebSocketSession session = this.delegateSession; Assert.state(session != null, "Cannot create message without a session"); if (Type.TEXT.equals(type)) { byte[] bytes = ((String) message).getBytes(StandardCharsets.UTF_8); DataBuffer buffer = session.bufferFactory().wrap(bytes); return new WebSocketMessage(Type.TEXT, buffer); } else if (Type.BINARY.equals(type)) { DataBuffer buffer = session.bufferFactory().wrap((ByteBuffer) message); return new WebSocketMessage(Type.BINARY, buffer); } else if (Type.PONG.equals(type)) { DataBuffer buffer = session.bufferFactory().wrap((ByteBuffer) message); return new WebSocketMessage(Type.PONG, buffer); } else { throw new IllegalArgumentException("Unexpected message type: " + message); } }
@Override public Mono<Void> write(Publisher<? extends MultiValueMap<String, String>> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints) { mediaType = getMediaType(mediaType); message.getHeaders().setContentType(mediaType); Charset charset = mediaType.getCharset(); Assert.notNull(charset, "No charset"); // should never occur return Mono.from(inputStream).flatMap(form -> { logFormData(form, hints); String value = serializeForm(form, charset); ByteBuffer byteBuffer = charset.encode(value); DataBuffer buffer = message.bufferFactory().wrap(byteBuffer); message.getHeaders().setContentLength(byteBuffer.remaining()); return message.writeWith(Mono.just(buffer)); }); }
@Override public Mono<Void> render(@Nullable Map<String, ?> model, @Nullable MediaType contentType, ServerWebExchange exchange) { StringBuilder builder = new StringBuilder(); builder.append("name=").append(this.name).append('\n'); for (Map.Entry<String, ?> entry : model.entrySet()) { builder.append(entry.getKey()).append('=').append(entry.getValue()).append('\n'); } builder.setLength(builder.length() - 1); byte[] bytes = builder.toString().getBytes(StandardCharsets.UTF_8); ServerHttpResponse response = exchange.getResponse(); DataBuffer buffer = response.bufferFactory().wrap(bytes); response.getHeaders().setContentType(MediaType.TEXT_PLAIN); return response.writeWith(Mono.just(buffer)); } }
private Flux<DataBuffer> getRegionPrefix(DataBufferFactory bufferFactory, byte[] startBoundary, byte[] contentType, ResourceRegion region) { return Flux.defer(() -> Flux.just( bufferFactory.allocateBuffer(startBoundary.length).write(startBoundary), bufferFactory.allocateBuffer(contentType.length).write(contentType), bufferFactory.wrap(ByteBuffer.wrap(getContentRangeHeader(region)))) ); }
@Override @Nullable protected DataBuffer read() throws IOException { PooledByteBuffer pooledByteBuffer = this.byteBufferPool.allocate(); boolean release = true; try { ByteBuffer byteBuffer = pooledByteBuffer.getBuffer(); int read = this.channel.read(byteBuffer); if (rsReadLogger.isTraceEnabled()) { rsReadLogger.trace(getLogPrefix() + "Read " + read + (read != -1 ? " bytes" : "")); } if (read > 0) { byteBuffer.flip(); DataBuffer dataBuffer = this.bufferFactory.wrap(byteBuffer); release = false; return new UndertowDataBuffer(dataBuffer, pooledByteBuffer); } else if (read == -1) { onAllDataRead(); } return null; } finally { if (release && pooledByteBuffer.isOpen()) { pooledByteBuffer.close(); } } }
@Override public MockServerHttpRequest body(String body) { return body(Flux.just(BUFFER_FACTORY.wrap(body.getBytes(getCharset())))); }
private <T> WebSocketMessage toMessage(Type type, T message) { if (Type.TEXT.equals(type)) { byte[] bytes = ((String) message).getBytes(StandardCharsets.UTF_8); return new WebSocketMessage(Type.TEXT, this.session.bufferFactory().wrap(bytes)); } else if (Type.BINARY.equals(type)) { DataBuffer buffer = this.session.bufferFactory().allocateBuffer().write((ByteBuffer[]) message); return new WebSocketMessage(Type.BINARY, buffer); } else if (Type.PONG.equals(type)) { DataBuffer buffer = this.session.bufferFactory().allocateBuffer().write((ByteBuffer[]) message); return new WebSocketMessage(Type.PONG, buffer); } else { throw new IllegalArgumentException("Unexpected message type: " + message); } }