How to use

MessageSerializer

in

org.apache.flink.queryablestate.network.messages

/**
 * Tests response serialization with zero-length serialized result.
 */
@Test
public void testResponseSerializationWithZeroLengthSerializedResult() throws Exception {
  byte[] serializedResult = new byte[0];
  final KvStateResponse response = new KvStateResponse(serializedResult);
  final MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  ByteBuf buf = MessageSerializer.serializeResponse(alloc, 72727278L, response);
  int frameLength = buf.readInt();
  assertEquals(MessageType.REQUEST_RESULT, MessageSerializer.deserializeHeader(buf));
  assertEquals(72727278L, MessageSerializer.getRequestId(buf));
  KvStateResponse responseDeser = serializer.deserializeResponse(buf);
  assertEquals(buf.readerIndex(), frameLength + 4);
  assertArrayEquals(serializedResult, responseDeser.getContent());
}

final MessageType msgType = MessageSerializer.deserializeHeader(buf);
requestId = MessageSerializer.getRequestId(buf);
  request = serializer.deserializeRequest(buf);
  stats.reportRequest();
  final ByteBuf failure = MessageSerializer.serializeServerFailure(ctx.alloc(), new IllegalArgumentException(errMsg));
if (request != null) {
  errMsg = "Failed request with ID " + requestId + ". Caused by: " + stringifiedCause;
  err = MessageSerializer.serializeRequestFailure(ctx.alloc(), requestId, new RuntimeException(errMsg));
  stats.reportFailedRequest();
} else {
  errMsg = "Failed incoming message. Caused by: " + stringifiedCause;
  err = MessageSerializer.serializeServerFailure(ctx.alloc(), new RuntimeException(errMsg));

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  try {
    ByteBuf buf = (ByteBuf) msg;
    MessageType msgType = MessageSerializer.deserializeHeader(buf);
    if (msgType == MessageType.REQUEST_RESULT) {
      long requestId = MessageSerializer.getRequestId(buf);
      RESP result = serializer.deserializeResponse(buf);
      callback.onRequestResult(requestId, result);
    } else if (msgType == MessageType.REQUEST_FAILURE) {
      RequestFailure failure = MessageSerializer.deserializeRequestFailure(buf);
      callback.onRequestFailure(failure.getRequestId(), failure.getCause());
    } else if (msgType == MessageType.SERVER_FAILURE) {
      throw MessageSerializer.deserializeServerFailure(buf);
    } else {
      throw new IllegalStateException("Unexpected response type '" + msgType + "'");
    }
  } catch (Throwable t1) {
    try {
      callback.onFailure(t1);
    } catch (Throwable t2) {
      LOG.error("Failed to notify callback about failure", t2);
    }
  } finally {
    ReferenceCountUtil.release(msg);
  }
}

  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    ByteBuf buf = (ByteBuf) msg;
    assertEquals(MessageType.REQUEST, MessageSerializer.deserializeHeader(buf));
    long requestId = MessageSerializer.getRequestId(buf);
    KvStateInternalRequest request = serializer.deserializeRequest(buf);
    buf.release();
    KvStateResponse response = new KvStateResponse(serializedResult);
    ByteBuf serResponse = MessageSerializer.serializeResponse(
        ctx.alloc(),
        requestId,
        response);
    ctx.channel().writeAndFlush(serResponse);
  }
});

/**
 * Tests the failure response with {@link UnknownKvStateIdException} as cause on
 * queries for unregistered KvStateIDs.
 */
@Test
public void testQueryUnknownKvStateID() throws Exception {
  KvStateRegistry registry = new KvStateRegistry();
  AtomicKvStateRequestStats stats = new AtomicKvStateRequestStats();
  MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  KvStateServerHandler handler = new KvStateServerHandler(testServer, registry, serializer, stats);
  EmbeddedChannel channel = new EmbeddedChannel(getFrameDecoder(), handler);
  long requestId = Integer.MAX_VALUE + 182828L;
  KvStateInternalRequest request = new KvStateInternalRequest(new KvStateID(), new byte[0]);
  ByteBuf serRequest = MessageSerializer.serializeRequest(channel.alloc(), requestId, request);
  // Write the request and wait for the response
  channel.writeInbound(serRequest);
  ByteBuf buf = (ByteBuf) readInboundBlocking(channel);
  buf.skipBytes(4); // skip frame length
  // Verify the response
  assertEquals(MessageType.REQUEST_FAILURE, MessageSerializer.deserializeHeader(buf));
  RequestFailure response = MessageSerializer.deserializeRequestFailure(buf);
  assertEquals(requestId, response.getRequestId());
  assertTrue("Did not respond with expected failure cause", response.getCause() instanceof UnknownKvStateIdException);
  assertEquals(1L, stats.getNumRequests());
  assertEquals(1L, stats.getNumFailed());
}

new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
assertNotNull("Channel not active", ch);
assertEquals(MessageType.REQUEST, MessageSerializer.deserializeHeader(buf));
long requestId = MessageSerializer.getRequestId(buf);
KvStateInternalRequest deserRequest = serializer.deserializeRequest(buf);
  ByteBuf response = MessageSerializer.serializeResponse(
      serverChannel.alloc(),
      requestId,
  ByteBuf response = MessageSerializer.serializeRequestFailure(
      serverChannel.alloc(),
      requestId,

/**
 * Tests request serialization with zero-length serialized key and namespace.
 */
@Test
public void testRequestSerializationWithZeroLengthKeyAndNamespace() throws Exception {
  long requestId = Integer.MAX_VALUE + 1337L;
  KvStateID kvStateId = new KvStateID();
  byte[] serializedKeyAndNamespace = new byte[0];
  final KvStateInternalRequest request = new KvStateInternalRequest(kvStateId, serializedKeyAndNamespace);
  final MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  ByteBuf buf = MessageSerializer.serializeRequest(alloc, requestId, request);
  int frameLength = buf.readInt();
  assertEquals(MessageType.REQUEST, MessageSerializer.deserializeHeader(buf));
  assertEquals(requestId, MessageSerializer.getRequestId(buf));
  KvStateInternalRequest requestDeser = serializer.deserializeRequest(buf);
  assertEquals(buf.readerIndex(), frameLength + 4);
  assertEquals(kvStateId, requestDeser.getKvStateId());
  assertArrayEquals(serializedKeyAndNamespace, requestDeser.getSerializedKeyAndNamespace());
}

    new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
    registryListener.kvStateId, serializedKeyAndNamespace);
ByteBuf serRequest = MessageSerializer.serializeRequest(channel.alloc(), requestId, request);
assertEquals(MessageType.REQUEST_RESULT, MessageSerializer.deserializeHeader(buf));
long deserRequestId = MessageSerializer.getRequestId(buf);
KvStateResponse response = serializer.deserializeResponse(buf);

    new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
final EmbeddedChannel channel = new EmbeddedChannel(new ClientHandler<>("Test Client", serializer, callback));
ByteBuf buf = MessageSerializer.serializeResponse(channel.alloc(), 1222112277L, response);
buf.skipBytes(4); // skip frame length
buf = MessageSerializer.serializeRequestFailure(
    channel.alloc(),
    1222112278,
buf = MessageSerializer.serializeServerFailure(
    channel.alloc(),
    new RuntimeException("Expected test Exception"));

    new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
assertEquals(MessageType.SERVER_FAILURE, MessageSerializer.deserializeHeader(buf));
Throwable response = MessageSerializer.deserializeServerFailure(buf);
unexpectedMessage = MessageSerializer.serializeResponse(channel.alloc(), 192L, stateResponse);
assertEquals(MessageType.SERVER_FAILURE, MessageSerializer.deserializeHeader(buf));
response = MessageSerializer.deserializeServerFailure(buf);

@Override
public AbstractServerHandler<KvStateInternalRequest, KvStateResponse> initializeHandler() {
  this.serializer = new MessageSerializer<>(
      new KvStateInternalRequest.KvStateInternalRequestDeserializer(),
      new KvStateResponse.KvStateResponseDeserializer());
  return new KvStateServerHandler(this, kvStateRegistry, serializer, stats);
}

/**
 * Tests server failure serialization.
 */
@Test
public void testServerFailureSerialization() throws Exception {
  IllegalStateException cause = new IllegalStateException("Expected test");
  ByteBuf buf = MessageSerializer.serializeServerFailure(alloc, cause);
  int frameLength = buf.readInt();
  assertEquals(MessageType.SERVER_FAILURE, MessageSerializer.deserializeHeader(buf));
  Throwable request = MessageSerializer.deserializeServerFailure(buf);
  assertEquals(buf.readerIndex(), frameLength + 4);
  assertEquals(cause.getClass(), request.getClass());
  assertEquals(cause.getMessage(), request.getMessage());
}

/**
 * Tests that the channel is closed if an Exception reaches the channel handler.
 */
@Test
public void testCloseChannelOnExceptionCaught() throws Exception {
  KvStateRegistry registry = new KvStateRegistry();
  AtomicKvStateRequestStats stats = new AtomicKvStateRequestStats();
  MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  KvStateServerHandler handler = new KvStateServerHandler(testServer, registry, serializer, stats);
  EmbeddedChannel channel = new EmbeddedChannel(handler);
  channel.pipeline().fireExceptionCaught(new RuntimeException("Expected test Exception"));
  ByteBuf buf = (ByteBuf) readInboundBlocking(channel);
  buf.skipBytes(4); // skip frame length
  // Verify the response
  assertEquals(MessageType.SERVER_FAILURE, MessageSerializer.deserializeHeader(buf));
  Throwable response = MessageSerializer.deserializeServerFailure(buf);
  assertTrue(response.getMessage().contains("Expected test Exception"));
  channel.closeFuture().await(READ_TIMEOUT_MILLIS);
  assertFalse(channel.isActive());
}

/**
 * Tests request failure serialization.
 */
@Test
public void testKvStateRequestFailureSerialization() throws Exception {
  long requestId = Integer.MAX_VALUE + 1111222L;
  IllegalStateException cause = new IllegalStateException("Expected test");
  ByteBuf buf = MessageSerializer.serializeRequestFailure(alloc, requestId, cause);
  int frameLength = buf.readInt();
  assertEquals(MessageType.REQUEST_FAILURE, MessageSerializer.deserializeHeader(buf));
  RequestFailure requestFailure = MessageSerializer.deserializeRequestFailure(buf);
  assertEquals(buf.readerIndex(), frameLength + 4);
  assertEquals(requestId, requestFailure.getRequestId());
  assertEquals(cause.getClass(), requestFailure.getCause().getClass());
  assertEquals(cause.getMessage(), requestFailure.getCause().getMessage());
}

final ByteBuf serialResp = MessageSerializer.serializeResponse(ctx.alloc(), requestId, resp);
try {
  stats.reportFailedRequest();
  final ByteBuf err = MessageSerializer.serializeRequestFailure(ctx.alloc(), requestId, e);
  ctx.writeAndFlush(err);
} catch (IOException io) {
  final ByteBuf err = MessageSerializer.serializeRequestFailure(ctx.alloc(), requestId, new RuntimeException(errMsg));
  ctx.writeAndFlush(err);
} catch (IOException io) {

  new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
ch.writeAndFlush(MessageSerializer.serializeServerFailure(
    serverChannel.alloc(),
    new RuntimeException("Expected test server failure")));

/**
 * Tests that incoming buffer instances are recycled.
 */
@Test
public void testIncomingBufferIsRecycled() throws Exception {
  KvStateRegistry registry = new KvStateRegistry();
  AtomicKvStateRequestStats stats = new AtomicKvStateRequestStats();
  MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  KvStateServerHandler handler = new KvStateServerHandler(testServer, registry, serializer, stats);
  EmbeddedChannel channel = new EmbeddedChannel(getFrameDecoder(), handler);
  KvStateInternalRequest request = new KvStateInternalRequest(new KvStateID(), new byte[0]);
  ByteBuf serRequest = MessageSerializer.serializeRequest(channel.alloc(), 282872L, request);
  assertEquals(1L, serRequest.refCnt());
  // Write regular request
  channel.writeInbound(serRequest);
  assertEquals("Buffer not recycled", 0L, serRequest.refCnt());
  // Write unexpected msg
  ByteBuf unexpected = channel.alloc().buffer(8);
  unexpected.writeInt(4);
  unexpected.writeInt(4);
  assertEquals(1L, unexpected.refCnt());
  channel.writeInbound(unexpected);
  assertEquals("Buffer not recycled", 0L, unexpected.refCnt());
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  final String msg = "Exception in server pipeline. Caused by: " + ExceptionUtils.stringifyException(cause);
  final ByteBuf err = MessageSerializer.serializeServerFailure(ctx.alloc(), new RuntimeException(msg));
  LOG.debug(msg);
  ctx.writeAndFlush(err).addListener(ChannelFutureListener.CLOSE);
}

    new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
ByteBuf serRequest = MessageSerializer.serializeRequest(channel.alloc(), 282872L, request);
assertEquals(MessageType.REQUEST_FAILURE, MessageSerializer.deserializeHeader(buf));
RequestFailure response = MessageSerializer.deserializeRequestFailure(buf);

/**
 * Tests request serialization.
 */
@Test
public void testRequestSerialization() throws Exception {
  long requestId = Integer.MAX_VALUE + 1337L;
  KvStateID kvStateId = new KvStateID();
  byte[] serializedKeyAndNamespace = randomByteArray(1024);
  final KvStateInternalRequest request = new KvStateInternalRequest(kvStateId, serializedKeyAndNamespace);
  final MessageSerializer<KvStateInternalRequest, KvStateResponse> serializer =
      new MessageSerializer<>(new KvStateInternalRequest.KvStateInternalRequestDeserializer(), new KvStateResponse.KvStateResponseDeserializer());
  ByteBuf buf = MessageSerializer.serializeRequest(alloc, requestId, request);
  int frameLength = buf.readInt();
  assertEquals(MessageType.REQUEST, MessageSerializer.deserializeHeader(buf));
  assertEquals(requestId, MessageSerializer.getRequestId(buf));
  KvStateInternalRequest requestDeser = serializer.deserializeRequest(buf);
  assertEquals(buf.readerIndex(), frameLength + 4);
  assertEquals(kvStateId, requestDeser.getKvStateId());
  assertArrayEquals(serializedKeyAndNamespace, requestDeser.getSerializedKeyAndNamespace());
}