@Override public void serialize(Message message) throws IOException { message.writeDelimitedTo(out); }
@Override public void writeTo(ResponseBuffer out) throws IOException { requestHeader.writeDelimitedTo(out); if (payload != null) { payload.writeDelimitedTo(out); } }
/** * Streams multiple messages to {@code output}. Reading the messages back requires to * call methods {@code readStream(...)}. * <p> * See https://developers.google.com/protocol-buffers/docs/techniques#streaming * </p> */ public static <MSG extends Message> void writeStream(Iterable<MSG> messages, OutputStream output) { try { for (Message message : messages) { message.writeDelimitedTo(output); } } catch (Exception e) { throw ContextException.of("Unable to write messages", e); } }
private DataBuffer encodeMessage(Message message, DataBufferFactory bufferFactory, boolean streaming) { DataBuffer buffer = bufferFactory.allocateBuffer(); OutputStream outputStream = buffer.asOutputStream(); try { if (streaming) { message.writeDelimitedTo(outputStream); } else { message.writeTo(outputStream); } return buffer; } catch (IOException ex) { throw new IllegalStateException("Unexpected I/O error while writing to data buffer", ex); } }
private DataBuffer encodeMessage(Message message, DataBufferFactory bufferFactory, boolean streaming) { DataBuffer buffer = bufferFactory.allocateBuffer(); OutputStream outputStream = buffer.asOutputStream(); try { if (streaming) { message.writeDelimitedTo(outputStream); } else { message.writeTo(outputStream); } return buffer; } catch (IOException ex) { throw new IllegalStateException("Unexpected I/O error while writing to data buffer", ex); } }
@Override void writeTo(ResponseBuffer out) throws IOException { int length = message.getSerializedSize(); length += CodedOutputStream.computeRawVarint32Size(length); out.ensureCapacity(length); message.writeDelimitedTo(out); }
((Message)instance).writeDelimitedTo( DataOutputOutputStream.constructOutputStream(out)); } else {
public Message callBlockingMethod(MethodDescriptorContainer methodDescriptor, Message request) throws ServiceException { try { dataOutputStream.writeUTF(methodDescriptor.getServiceDescriptorContainer().getName()); dataOutputStream.writeUTF(methodDescriptor.getName()); dataOutputStream.writeUTF(tokenHolder.getToken() == null ? "" : tokenHolder.getToken()); request.writeDelimitedTo(dataOutputStream); dataOutputStream.flush(); DynamicMessage response = DynamicMessage.getDefaultInstance(methodDescriptor.getOutputDescriptor()); Builder responseBuilder = response.newBuilderForType(); responseBuilder.mergeDelimitedFrom(inputStream); return responseBuilder.build(); } catch (IOException e) { LOGGER.error("", e); } return null; }
DynamicMessage request = newBuilder.build(); Message response = reflectiveRpcChannel.callBlockingMethod(methodDescriptorContainer, request); response.writeDelimitedTo(socket.getOutputStream()); } catch (ServiceNotFoundException e) {
requestBuilder.mergeDelimitedFrom(dataInputStream); Message response = reflectiveRpcChannel.callBlockingMethod(pbMethod, requestBuilder.build()); response.writeDelimitedTo(outputStream); outputStream.flush();
public static <T extends Message> void writeMessage(OutputStream output, T message) { try { message.writeDelimitedTo(output); } catch (IOException e) { throw new IllegalStateException("failed to write message: " + message, e); } } }
@Override public void write(DataOutput out) throws IOException { OutputStream os = DataOutputOutputStream.constructOutputStream(out); ((Message)requestHeader).writeDelimitedTo(os); theRequest.writeDelimitedTo(os); }
@Override public void write(DataOutput out) throws IOException { OutputStream os = DataOutputOutputStream.constructOutputStream(out); ((Message)requestHeader).writeDelimitedTo(os); theRequest.writeDelimitedTo(os); }
/** * @param m * Message to get delimited pb serialization of (with pb magic * prefix) */ public static byte[] toDelimitedByteArray(final Message m) throws IOException { // Allocate arbitrary big size so we avoid resizing. ByteArrayOutputStream baos = new ByteArrayOutputStream(4096); m.writeDelimitedTo(baos); baos.close(); return baos.toByteArray(); }
private static void send(final DataOutputStream out, final Op opcode, final Message proto) throws IOException { LOG.trace("Sending DataTransferOp {}: {}", proto.getClass().getSimpleName(), proto); op(out, opcode); proto.writeDelimitedTo(out); out.flush(); }
@Override public void write(DataOutput out) throws IOException { OutputStream os = DataOutputOutputStream.constructOutputStream(out); theResponse.writeDelimitedTo(os); }
@Override protected void writeInternal(Object o, HttpOutputMessage httpOutputMessage) throws IOException, HttpMessageNotWritableException { // Use writeDelimited to avoid empty request/response bodies as Spring 4.x does not work with them, // it's a real shame we have to do this, but there is simply no other choice without significant complication of // the rest of the code. The reason why it is done here is because Spring became more strict about parsing // request body (and response body as well) and what worked before simply doesn't work anymore. final Message message = (Message) o; message.writeDelimitedTo(httpOutputMessage.getBody()); }
@Override public void writeTo(ResponseBuffer out) throws IOException { requestHeader.writeDelimitedTo(out); if (payload != null) { payload.writeDelimitedTo(out); } }
@Override public void encode(T value, OutputStream outStream, Context context) throws IOException { if (value == null) { throw new CoderException("cannot encode a null " + protoMessageClass.getSimpleName()); } if (context.isWholeStream) { value.writeTo(outStream); } else { value.writeDelimitedTo(outStream); } }
@Override void writeTo(ResponseBuffer out) throws IOException { int length = message.getSerializedSize(); length += CodedOutputStream.computeRawVarint32Size(length); out.ensureCapacity(length); message.writeDelimitedTo(out); }