/** * Creates a msgpack pipe from an {@link InputStream}. */ public static Pipe newPipe(InputStream in, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); return newPipe(unpacker, numeric); }
/** * Serializes the {@code message} into an {@link OutputStream} using the given {@code schema}. */ public static <T> void writeTo(OutputStream out, T message, Schema<T> schema, boolean numeric) throws IOException { MessagePacker packer = MessagePack.newDefaultPacker(out); try { writeTo(packer, message, schema, numeric); } finally { packer.flush(); } }
MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(clientSocket.getInputStream()); assertEquals(3, unpacker.unpackArrayHeader()); assertEquals("foo.bar", unpacker.unpackString()); assertNotNull(map.get(KEY_OPTION_CHUNK).asRawValue().asString()); MessagePacker packer = MessagePack.newDefaultPacker(clientSocket.getOutputStream()); packer.packMapHeader(1) .packString("ack").packString(UUID.randomUUID().toString())
public static DirectBuffer encodeMsgPack(CheckedConsumer<MessageBufferPacker> msgWriter) { final MessageBufferPacker packer = MessagePack.newDefaultBufferPacker(); try { msgWriter.accept(packer); packer.close(); } catch (Exception e) { throw new RuntimeException(e); } final byte[] bytes = packer.toByteArray(); return new UnsafeBuffer(bytes); }
MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(clientSocket.getInputStream()); assertEquals(3, unpacker.unpackArrayHeader()); assertEquals("foo.bar", unpacker.unpackString()); assertNotNull(ackResponseToken); MessagePacker packer = MessagePack.newDefaultPacker(clientSocket.getOutputStream()); packer.packMapHeader(1) .packString("ack").packString(ackResponseToken)
public static DirectBuffer encodeMsgPack(CheckedConsumer<MessageBufferPacker> msgWriter) { final MessageBufferPacker packer = MessagePack.newDefaultBufferPacker(); try { msgWriter.accept(packer); packer.close(); } catch (Exception e) { throw new RuntimeException(e); } final byte[] bytes = packer.toByteArray(); return new UnsafeBuffer(bytes); }
/** * Creates a msgpack pipe from an {@link MessageBufferInput}. */ public static Pipe newPipe(MessageBufferInput in, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); return newPipe(unpacker, numeric); }
/** * Serializes the {@code message} into an {@link MessageBufferOutput} using the given {@code schema}. */ public static <T> void writeTo(MessageBufferOutput out, T message, Schema<T> schema, boolean numeric) throws IOException { MessagePacker packer = MessagePack.newDefaultPacker(out); try { writeTo(packer, message, schema, numeric); } finally { packer.flush(); } }
/** * Merges the {@code message} from the {@link MessageBufferInput} using the given {@code schema}. */ public static <T> void mergeFrom(MessageBufferInput in, T message, Schema<T> schema, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); try { mergeFrom(unpacker, message, schema, numeric); } finally { unpacker.close(); } }
/** * Serializes the {@code messages} into the stream using the given schema. */ public static <T> void writeListTo(OutputStream out, List<T> messages, Schema<T> schema, boolean numeric) throws IOException { MessagePacker packer = MessagePack.newDefaultPacker(out); try { writeListTo(packer, messages, schema, numeric); } finally { packer.flush(); } }
/** * Merges the {@code message} from the {@link InputStream} using the given {@code schema}. */ public static <T> void mergeFrom(InputStream in, T message, Schema<T> schema, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); try { mergeFrom(unpacker, message, schema, numeric); } finally { unpacker.close(); } }
/** * Serializes the {@code messages} into the stream using the given schema. */ public static <T> void writeListTo(MessageBufferOutput out, List<T> messages, Schema<T> schema, boolean numeric) throws IOException { MessagePacker packer = MessagePack.newDefaultPacker(out); try { writeListTo(packer, messages, schema, numeric); } finally { packer.flush(); } }
/** * Parses the {@code messages} from the stream using the given {@code schema}. */ public static <T> List<T> parseListFrom(MessageBufferInput in, Schema<T> schema, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); try { return parseListFrom(unpacker, schema, numeric); } finally { unpacker.close(); } }
MessagePacker packer = MessagePack.newDefaultPacker(out) .packMapHeader(numberOfFieldsMappedInHeader(keyValue)) .packInt(KAFKA_MESSAGE_OFFSET)
/** * Parses the {@code messages} from the stream using the given {@code schema}. */ public static <T> List<T> parseListFrom(InputStream in, Schema<T> schema, boolean numeric) throws IOException { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(in); try { return parseListFrom(unpacker, schema, numeric); } finally { unpacker.close(); } }
@Override public void serialize(@NonNull BElement element, @NonNull OutputStream out) { try (var packer = MessagePack.newDefaultPacker(out)) { packAny(element, packer); packer.flush(); } catch (IOException e) { throw new BeanSerializationException("Error while serialize element", e); } }
/** * Merges the {@code message} with the byte array using the given {@code schema}. */ public static <T> void mergeFrom(byte[] data, int offset, int length, T message, Schema<T> schema, boolean numeric) throws IOException { ArrayBufferInput bios = new ArrayBufferInput(data, offset, length); MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bios); try { mergeFrom(unpacker, message, schema, numeric); } finally { unpacker.close(); } }
@Override public void serialize(T t, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException { var messagePackGenerator = (MessagePackGenerator) jsonGenerator; var byteArrayOutputStream = new ByteArrayOutputStream(); MessagePack.newDefaultPacker(byteArrayOutputStream).packLong(t.getId()).close(); var messagePackExtensionType = new MessagePackExtensionType(typeId, byteArrayOutputStream.toByteArray()); messagePackGenerator.writeExtensionType(messagePackExtensionType); } }
@Override public KeyValue next() throws IOException { if (mReader.next(mKey, mValue)) { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(mKey.getBytes()); int mapSize = unpacker.unpackMapHeader(); long offset = 0; long timestamp = -1; byte[] keyBytes = EMPTY_BYTES; for (int i = 0; i < mapSize; i++) { int key = unpacker.unpackInt(); switch (key) { case KAFKA_MESSAGE_OFFSET: offset = unpacker.unpackLong(); break; case KAFKA_MESSAGE_TIMESTAMP: timestamp = unpacker.unpackLong(); break; case KAFKA_HASH_KEY: int keySize = unpacker.unpackBinaryHeader(); keyBytes = new byte[keySize]; unpacker.readPayload(keyBytes); break; } } unpacker.close(); return new KeyValue(offset, keyBytes, Arrays.copyOfRange(mValue.getBytes(), 0, mValue.getLength()), timestamp); } else { return null; } }
@Override public void ingest(String tag, ByteBuffer dataBuffer) throws IOException { ByteArrayOutputStream header = new ByteArrayOutputStream(); MessagePacker messagePacker = MessagePack.newDefaultPacker(header); int dataLength = dataBuffer.limit(); messagePacker.packArrayHeader(3); messagePacker.packString(tag); messagePacker.packRawStringHeader(dataLength); messagePacker.flush(); ByteBuffer headerBuffer = ByteBuffer.wrap(header.toByteArray()); if (config.isAckResponseMode()) { byte[] uuidBytes = UUID.randomUUID().toString().getBytes(CHARSET); ByteBuffer optionBuffer = ByteBuffer.wrap(objectMapper.writeValueAsBytes(new RequestOption(dataLength, uuidBytes))); List<ByteBuffer> buffers = Arrays.asList(headerBuffer, dataBuffer, optionBuffer); synchronized (sender) { sender.sendWithAck(buffers, uuidBytes); } } else { ByteBuffer optionBuffer = ByteBuffer.wrap(objectMapper.writeValueAsBytes(new RequestOption(dataLength, null))); List<ByteBuffer> buffers = Arrays.asList(headerBuffer, dataBuffer, optionBuffer); synchronized (sender) { sender.send(buffers); } } }