/** * Construct an instance using a {@link ByteArrayLfSerializer} for * non-transparent frames. */ public RFC6587SyslogDeserializer() { this.delimitedDeserializer = new ByteArrayLfSerializer(); }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayRawSerializer}. * @since 5.1.3 */ public static ByteArrayRawSerializer raw(int maxMessageSize) { ByteArrayRawSerializer codec = new ByteArrayRawSerializer(); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayStxEtxSerializer}. * @since 5.1.3 */ public static ByteArrayStxEtxSerializer stxetx(int maxMessageSize) { ByteArrayStxEtxSerializer codec = new ByteArrayStxEtxSerializer(); codec.setMaxMessageSize(maxMessageSize); return codec; }
@Test public void deserializationEvents() throws Exception { doDeserialize(new ByteArrayCrLfSerializer(), "CRLF not found before max message length: 5"); doDeserialize(new ByteArrayLengthHeaderSerializer(), "Message length 1718579042 exceeds max message length: 5"); TcpDeserializationExceptionEvent event = doDeserialize(new ByteArrayLengthHeaderSerializer(), "Stream closed after 3 of 4", new byte[] { 0, 0, 0 }, 5); // closed during header read assertEquals(-1, event.getOffset()); assertEquals(new String(new byte[] { 0, 0, 0 }), new String(event.getBuffer()).substring(0, 3)); event = doDeserialize(new ByteArrayLengthHeaderSerializer(), "Stream closed after 1 of 2", new byte[] { 0, 0, 0, 2, 7 }, 5); // closed during data read assertEquals(-1, event.getOffset()); assertEquals(new String(new byte[] { 7 }), new String(event.getBuffer()).substring(0, 1)); doDeserialize(new ByteArrayLfSerializer(), "Terminator '0xa' not found before max message length: 5"); doDeserialize(new ByteArrayRawSerializer(), "Socket was not closed before max message length: 5"); doDeserialize(new ByteArraySingleTerminatorSerializer((byte) 0xfe), "Terminator '0xfe' not found before max message length: 5"); doDeserialize(new ByteArrayStxEtxSerializer(), "Expected STX to begin message"); event = doDeserialize(new ByteArrayStxEtxSerializer(), "Socket closed during message assembly", new byte[] { 0x02, 0, 0 }, 5); assertEquals(2, event.getOffset()); }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayLfSerializer}. * @since 5.1.3 */ public static ByteArrayLfSerializer lf(int maxMessageSize) { ByteArrayLfSerializer codec = new ByteArrayLfSerializer(); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayLengthHeaderSerializer} with a 2 byte header. * @since 5.1.3 */ public static ByteArrayLengthHeaderSerializer lengthHeader2(int maxMessageSize) { ByteArrayLengthHeaderSerializer codec = new ByteArrayLengthHeaderSerializer( ByteArrayLengthHeaderSerializer.HEADER_SIZE_UNSIGNED_SHORT); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the default max message size for deserialization. * @return a {@link ByteArrayLengthHeaderSerializer} with a 1 byte header. * @see AbstractByteArraySerializer#DEFAULT_MAX_MESSAGE_SIZE */ public static ByteArrayLengthHeaderSerializer lengthHeader1() { if (oneByteLHS == null) { oneByteLHS = new ByteArrayLengthHeaderSerializer(ByteArrayLengthHeaderSerializer.HEADER_SIZE_UNSIGNED_BYTE); } return oneByteLHS; }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayCrLfSerializer}. * @since 5.1.3 */ public static ByteArrayCrLfSerializer crlf(int maxMessageSize) { ByteArrayCrLfSerializer codec = new ByteArrayCrLfSerializer(); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the provided max message size for deserialization. * @param terminator the terminator indicating message end. * @param maxMessageSize the max message size. * @return a {@link ByteArraySingleTerminatorSerializer} using the supplied * terminator. * @since 5.1.3 */ public static ByteArraySingleTerminatorSerializer singleTerminator(byte terminator, int maxMessageSize) { ByteArraySingleTerminatorSerializer codec = new ByteArraySingleTerminatorSerializer(terminator); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the default max message size for deserialization. * @param terminator the terminator indicating message end. * @return a {@link ByteArraySingleTerminatorSerializer} using the supplied * terminator. * @see AbstractByteArraySerializer#DEFAULT_MAX_MESSAGE_SIZE */ public static ByteArraySingleTerminatorSerializer singleTerminator(byte terminator) { return new ByteArraySingleTerminatorSerializer(terminator); }
@Override public byte[] deserialize(InputStream inputStream) throws IOException { PushbackInputStream pbis = (PushbackInputStream) inputStream; int first = pbis.read(); if (first < 0) { throw new SoftEndOfStreamException(); } pbis.unread(first); if (first == ByteArrayStxEtxSerializer.STX) { this.receivedStxEtx = true; return this.stxEtx.deserialize(pbis); } else { this.receivedCrLf = true; return this.crlf.deserialize(pbis); } }
@Test public void testTimeoutWithRawDeserializer() throws Exception { testTimeoutWhileDecoding(new ByteArrayRawSerializer(), "reply"); }
/** * Reads the data in the inputStream to a byte[]. Data must be terminated * by CRLF (\r\n). Throws a {@link SoftEndOfStreamException} if the stream * is closed immediately after the \r\n (i.e. no data is in the process of * being read). */ @Override public byte[] doDeserialize(InputStream inputStream, byte[] buffer) throws IOException { int n = this.fillToCrLf(inputStream, buffer); return this.copyToSizedArray(buffer, n); }
@Override public byte[] createForPool() { return new byte[getMaxMessageSize()]; }
/** * Writes the byte[] to the output stream, preceded by a 4 byte * length in network byte order (big endian). * * @param bytes The bytes. * @param outputStream The output stream. */ @Override public void serialize(byte[] bytes, OutputStream outputStream) throws IOException { this.writeHeader(outputStream, bytes.length); outputStream.write(bytes); }
@Test public void testTimeoutWithCustomDeserializer() throws Exception { testTimeoutWhileDecoding(new CustomDeserializer(), "\u0000\u0002\u0000\u0005reply"); }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayLengthHeaderSerializer} with a 4 byte header. * @since 5.1.3 */ public static ByteArrayLengthHeaderSerializer lengthHeader4(int maxMessageSize) { ByteArrayLengthHeaderSerializer codec = new ByteArrayLengthHeaderSerializer( ByteArrayLengthHeaderSerializer.HEADER_SIZE_INT); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the default max message size for deserialization. * @return a {@link ByteArrayLengthHeaderSerializer} with a 4 byte header. * @see AbstractByteArraySerializer#DEFAULT_MAX_MESSAGE_SIZE */ public static ByteArrayLengthHeaderSerializer lengthHeader4() { if (fourByteLHS == null) { fourByteLHS = new ByteArrayLengthHeaderSerializer(ByteArrayLengthHeaderSerializer.HEADER_SIZE_INT); } return fourByteLHS; }
/** * Return a serializer with the provided max message size for deserialization. * @param maxMessageSize the max message size. * @return a {@link ByteArrayLengthHeaderSerializer} with a 1 byte header. * @since 5.1.3 */ public static ByteArrayLengthHeaderSerializer lengthHeader1(int maxMessageSize) { ByteArrayLengthHeaderSerializer codec = new ByteArrayLengthHeaderSerializer( ByteArrayLengthHeaderSerializer.HEADER_SIZE_UNSIGNED_BYTE); codec.setMaxMessageSize(maxMessageSize); return codec; }
/** * Return a serializer with the default max message size for deserialization. * @return a {@link ByteArrayLengthHeaderSerializer} with a 2 byte header. * @see AbstractByteArraySerializer#DEFAULT_MAX_MESSAGE_SIZE */ public static ByteArrayLengthHeaderSerializer lengthHeader2() { if (twoByteLHS == null) { twoByteLHS = new ByteArrayLengthHeaderSerializer( ByteArrayLengthHeaderSerializer.HEADER_SIZE_UNSIGNED_SHORT); } return twoByteLHS; }