Http2Writer(BufferedSink sink, boolean client) { this.sink = sink; this.client = client; this.hpackBuffer = new Buffer(); this.hpackWriter = new Hpack.Writer(hpackBuffer); this.maxFrameSize = INITIAL_MAX_FRAME_SIZE; }
@Override public RequestBody convert(final T value) throws IOException { Buffer buffer = new Buffer(); try { Marshaller marshaller = context.createMarshaller(); XMLStreamWriter xmlWriter = xmlOutputFactory.createXMLStreamWriter( buffer.outputStream(), JaxbConverterFactory.XML.charset().name()); marshaller.marshal(value, xmlWriter); } catch (JAXBException | XMLStreamException e) { throw new RuntimeException(e); } return RequestBody.create(JaxbConverterFactory.XML, buffer.readByteString()); } }
@Override public RequestBody convert(T value) throws IOException { Buffer buffer = new Buffer(); adapter.encode(buffer, value); return RequestBody.create(MEDIA_TYPE, buffer.snapshot()); } }
/** Returns a new response body that transmits {@code content}. */ public static ResponseBody create(final @Nullable MediaType contentType, byte[] content) { Buffer buffer = new Buffer().write(content); return create(contentType, content.length, buffer); }
@Override public RequestBody convert(T value) throws IOException { Buffer buffer = new Buffer(); try { OutputStreamWriter osw = new OutputStreamWriter(buffer.outputStream(), CHARSET); serializer.write(value, osw); osw.flush(); } catch (RuntimeException | IOException e) { throw e; } catch (Exception e) { throw new RuntimeException(e); } return RequestBody.create(MEDIA_TYPE, buffer.readByteString()); } }
static ResponseBody buffer(final ResponseBody body) throws IOException { Buffer buffer = new Buffer(); body.source().readAll(buffer); return ResponseBody.create(body.contentType(), body.contentLength(), buffer); }
private Buffer fileToBytes(File file) throws IOException { Buffer result = new Buffer(); result.writeAll(Okio.source(file)); return result; }
/** * Sets the response body to the UTF-8 encoded bytes of {@code body}, chunked every {@code * maxChunkSize} bytes. */ public MockResponse setChunkedBody(String body, int maxChunkSize) { return setChunkedBody(new Buffer().writeUtf8(body), maxChunkSize); }
/** Sets the response body to the UTF-8 encoded bytes of {@code body}. */ public MockResponse setBody(String body) { return setBody(new Buffer().writeUtf8(body)); }
static String percentDecode(String encoded, int pos, int limit, boolean plusIsSpace) { for (int i = pos; i < limit; i++) { char c = encoded.charAt(i); if (c == '%' || (c == '+' && plusIsSpace)) { // Slow path: the character at i requires decoding! Buffer out = new Buffer(); out.writeUtf8(encoded, pos, i); percentDecode(out, encoded, i, limit, plusIsSpace); return out.readUtf8(); } } // Fast path: no characters in [pos..limit) required decoding. return encoded.substring(pos, limit); }
@Override public RequestBody convert(T value) throws IOException { Buffer buffer = new Buffer(); JsonWriter writer = JsonWriter.of(buffer); adapter.toJson(writer, value); return RequestBody.create(MEDIA_TYPE, buffer.readByteString()); } }
/** Returns a new response body that transmits {@code content}. */ public static ResponseBody create(@Nullable MediaType contentType, ByteString content) { Buffer buffer = new Buffer().write(content); return create(contentType, content.size(), buffer); }
/** * Returns the concatenation of 8-bit, length prefixed protocol names. * http://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04#page-4 */ static byte[] concatLengthPrefixed(List<Protocol> protocols) { Buffer result = new Buffer(); for (int i = 0, size = protocols.size(); i < size; i++) { Protocol protocol = protocols.get(i); if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN. result.writeByte(protocol.toString().length()); result.writeUtf8(protocol.toString()); } return result.readByteArray(); }
private void writeMetadata(long upstreamSize) throws IOException { Buffer metadataBuffer = new Buffer(); metadataBuffer.write(metadata); FileOperator fileOperator = new FileOperator(file.getChannel()); fileOperator.write(FILE_HEADER_SIZE + upstreamSize, metadataBuffer, metadata.size()); }
@Override public String convert(T value) throws IOException { Buffer buffer = new Buffer(); delegate.convert(value).writeTo(buffer); return buffer.readUtf8(); } }
@Override public RequestBody convert(T value) throws IOException { Buffer buffer = new Buffer(); Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8); JsonWriter jsonWriter = gson.newJsonWriter(writer); adapter.write(jsonWriter, value); jsonWriter.close(); return RequestBody.create(MEDIA_TYPE, buffer.readByteString()); } }
/** * Returns a new response body that transmits {@code content}. If {@code contentType} is non-null * and lacks a charset, this will use UTF-8. */ public static ResponseBody create(@Nullable MediaType contentType, String content) { Charset charset = UTF_8; if (contentType != null) { charset = contentType.charset(); if (charset == null) { charset = UTF_8; contentType = MediaType.parse(contentType + "; charset=utf-8"); } } Buffer buffer = new Buffer().writeString(content, charset); return create(contentType, buffer.size(), buffer); }
private void writeHeader( ByteString prefix, long upstreamSize, long metadataSize) throws IOException { Buffer header = new Buffer(); header.write(prefix); header.writeLong(upstreamSize); header.writeLong(metadataSize); if (header.size() != FILE_HEADER_SIZE) throw new IllegalArgumentException(); FileOperator fileOperator = new FileOperator(file.getChannel()); fileOperator.write(0, header, FILE_HEADER_SIZE); }
@Override public void writeTo(BufferedSink sink) throws IOException { Buffer buffer = new Buffer(); while (pipe.source().read(buffer, 8192) != -1L) { sink.write(buffer, buffer.size()); } } }
void writeByteString(ByteString data) throws IOException { if (useCompression && Huffman.get().encodedLength(data) < data.size()) { Buffer huffmanBuffer = new Buffer(); Huffman.get().encode(data, huffmanBuffer); ByteString huffmanBytes = huffmanBuffer.readByteString(); writeInt(huffmanBytes.size(), PREFIX_7_BITS, 0x80); out.write(huffmanBytes); } else { writeInt(data.size(), PREFIX_7_BITS, 0); out.write(data); } }