Example usage for org.apache.commons.lang3 SerializationUtils serialize

Introduction

In this page you can find the example usage for org.apache.commons.lang3 SerializationUtils serialize.

Prototype

public static byte[] serialize(final Serializable obj) 

Source Link

Document

Serializes an Object to a byte array for storage/serialization.

Usage

From source file:org.opendaylight.controller.cluster.messaging.MessageAssemblerTest.java

@Test
public void testMessageSliceWithByteSourceFailure() throws IOException {
    try (MessageAssembler assembler = newMessageAssembler("testMessageSliceWithByteSourceFailure")) {
        IOException mockFailure = new IOException("mock IOException");
        doThrow(mockFailure).when(mockByteSource).openStream();
        doThrow(mockFailure).when(mockByteSource).openBufferedStream();

        final MessageSliceIdentifier identifier = new MessageSliceIdentifier(IDENTIFIER, 1);
        final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });

        final MessageSlice messageSlice = new MessageSlice(identifier, SerializationUtils.serialize(message), 1,
                1, SlicedMessageState.INITIAL_SLICE_HASH_CODE, testProbe.ref());
        assembler.handleMessage(messageSlice, testProbe.ref());

        final MessageSliceReply reply = testProbe.expectMsgClass(MessageSliceReply.class);
        assertFailedMessageSliceReply(reply, IDENTIFIER, false);
        assertEquals("Failure cause", mockFailure, reply.getFailure().get().getCause());

        assertFalse("MessageAssembler did not remove state for " + identifier, assembler.hasState(identifier));
        verify(mockFiledBackedStream).cleanup();
    }/* w ww.jav  a  2s .co m*/
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageAssemblerTest.java

@Test
public void testMessageSliceWithStreamWriteFailure() throws IOException {
    try (MessageAssembler assembler = newMessageAssembler("testMessageSliceWithStreamWriteFailure")) {
        IOException mockFailure = new IOException("mock IOException");
        doThrow(mockFailure).when(mockFiledBackedStream).write(any(byte[].class), anyInt(), anyInt());
        doThrow(mockFailure).when(mockFiledBackedStream).write(any(byte[].class));
        doThrow(mockFailure).when(mockFiledBackedStream).write(anyInt());
        doThrow(mockFailure).when(mockFiledBackedStream).flush();

        final MessageSliceIdentifier identifier = new MessageSliceIdentifier(IDENTIFIER, 1);
        final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });

        final MessageSlice messageSlice = new MessageSlice(identifier, SerializationUtils.serialize(message), 1,
                1, SlicedMessageState.INITIAL_SLICE_HASH_CODE, testProbe.ref());
        assembler.handleMessage(messageSlice, testProbe.ref());

        final MessageSliceReply reply = testProbe.expectMsgClass(MessageSliceReply.class);
        assertFailedMessageSliceReply(reply, IDENTIFIER, false);
        assertEquals("Failure cause", mockFailure, reply.getFailure().get().getCause());

        assertFalse("MessageAssembler did not remove state for " + identifier, assembler.hasState(identifier));
        verify(mockFiledBackedStream).cleanup();
    }/*from   w w w.j a va 2s  .  c  om*/
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageAssemblerTest.java

@Test
public void testAssembledMessageStateExpiration() throws IOException {
    final int expiryDuration = 200;
    try (MessageAssembler assembler = newMessageAssemblerBuilder("testAssembledMessageStateExpiration")
            .expireStateAfterInactivity(expiryDuration, TimeUnit.MILLISECONDS).build()) {
        final MessageSliceIdentifier identifier = new MessageSliceIdentifier(IDENTIFIER, 1);
        final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });

        final MessageSlice messageSlice = new MessageSlice(identifier, SerializationUtils.serialize(message), 1,
                2, SlicedMessageState.INITIAL_SLICE_HASH_CODE, testProbe.ref());
        assembler.handleMessage(messageSlice, testProbe.ref());

        final MessageSliceReply reply = testProbe.expectMsgClass(MessageSliceReply.class);
        assertSuccessfulMessageSliceReply(reply, IDENTIFIER, 1);

        assertTrue("MessageAssembler should have remove state for " + identifier,
                assembler.hasState(identifier));
        Uninterruptibles.sleepUninterruptibly(expiryDuration + 50, TimeUnit.MILLISECONDS);
        assertFalse("MessageAssembler did not remove state for " + identifier, assembler.hasState(identifier));

        verify(mockFiledBackedStream).cleanup();
    }/*from w  ww  . j a v a2 s .  c  o  m*/
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSlicingWithChunks() throws IOException {
    LOG.info("testSlicingWithChunks starting");

    // First slice a message where the messageSliceSize divides evenly into the serialized size.

    byte[] emptyMessageBytes = SerializationUtils.serialize(new BytesMessage(new byte[] {}));
    int messageSliceSize = 10;
    int expTotalSlices = emptyMessageBytes.length / messageSliceSize;
    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    if (emptyMessageBytes.length % messageSliceSize > 0) {
        expTotalSlices++;//from   ww w.  j  a  va2s. c o  m
        int padding = messageSliceSize - emptyMessageBytes.length % messageSliceSize;
        byte value = 1;
        for (int i = 0; i < padding; i++, value++) {
            byteStream.write(value);
        }
    }

    testSlicing("testSlicingWithChunks", messageSliceSize, expTotalSlices, byteStream.toByteArray());

    // Now slice a message where the messageSliceSize doesn't divide evenly.

    byteStream.write(new byte[] { 100, 101, 102 });
    testSlicing("testSlicingWithChunks", messageSliceSize, expTotalSlices + 1, byteStream.toByteArray());

    LOG.info("testSlicingWithChunks ending");
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSingleSlice() {
    LOG.info("testSingleSlice starting");

    // Slice a message where the serialized size is equal to the messageSliceSize. In this case it should
    // just send the original message.

    final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });
    try (MessageSlicer slicer = newMessageSlicer("testSingleSlice",
            SerializationUtils.serialize(message).length)) {
        final boolean wasSliced = slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(),
                mockOnFailureCallback);/*from  w w  w.ja v  a  2  s.  co  m*/
        assertFalse(wasSliced);

        final BytesMessage sentMessage = sendToProbe.expectMsgClass(BytesMessage.class);
        assertEquals("Sent message", message, sentMessage);
    }

    LOG.info("testSingleSlice ending");
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSlicingWithRetry() {
    LOG.info("testSlicingWithRetry starting");

    final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });
    final int messageSliceSize = SerializationUtils.serialize(message).length / 2;
    try (MessageSlicer slicer = newMessageSlicer("testSlicingWithRetry", messageSliceSize)) {
        slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(), mockOnFailureCallback);

        MessageSlice sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);
        assembler.handleMessage(sliceMessage, sendToProbe.ref());

        // Swallow the reply and send the MessageSlice again - it should return a failed reply.
        replyToProbe.expectMsgClass(MessageSliceReply.class);
        assembler.handleMessage(sliceMessage, sendToProbe.ref());

        final MessageSliceReply failedReply = replyToProbe.expectMsgClass(MessageSliceReply.class);
        assertFailedMessageSliceReply(failedReply, IDENTIFIER, true);

        // Send the failed reply - slicing should be retried from the beginning.

        slicer.handleMessage(failedReply);
        while (true) {
            sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);
            assembler.handleMessage(sliceMessage, sendToProbe.ref());

            final MessageSliceReply reply = replyToProbe.expectMsgClass(MessageSliceReply.class);
            assertSuccessfulMessageSliceReply(reply, IDENTIFIER, sliceMessage.getSliceIndex());
            slicer.handleMessage(reply);

            if (reply.getSliceIndex() == sliceMessage.getTotalSlices()) {
                break;
            }/* ww  w.  j  a v  a2  s  .c  o  m*/
        }

        assertAssembledMessage(message, replyToProbe.ref());
    }

    LOG.info("testSlicingWithRetry ending");
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSlicingWithMaxRetriesReached() {
    LOG.info("testSlicingWithMaxRetriesReached starting");

    final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });
    final int messageSliceSize = SerializationUtils.serialize(message).length / 2;
    try (MessageSlicer slicer = newMessageSlicer("testSlicingWithMaxRetriesReached", messageSliceSize)) {
        slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(), mockOnFailureCallback);

        Identifier slicingId = null;/*from ww w .  ja  v  a 2 s .  c  o  m*/
        for (int i = 0; i < MessageSlicer.DEFAULT_MAX_SLICING_TRIES; i++) {
            MessageSlice sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);
            slicingId = sliceMessage.getIdentifier();
            assertMessageSlice(sliceMessage, IDENTIFIER, 1, DONT_CARE,
                    SlicedMessageState.INITIAL_SLICE_HASH_CODE, replyToProbe.ref());
            assembler.handleMessage(sliceMessage, sendToProbe.ref());

            // Swallow the reply and send the MessageSlicer a reply with an invalid index.
            final MessageSliceReply reply = replyToProbe.expectMsgClass(MessageSliceReply.class);
            assertSuccessfulMessageSliceReply(reply, IDENTIFIER, sliceMessage.getSliceIndex());
            slicer.handleMessage(MessageSliceReply.success(reply.getIdentifier(), 100000, reply.getSendTo()));

            final AbortSlicing abortSlicing = sendToProbe.expectMsgClass(AbortSlicing.class);
            assertEquals("Identifier", slicingId, abortSlicing.getIdentifier());
            assembler.handleMessage(abortSlicing, sendToProbe.ref());
        }

        slicer.handleMessage(MessageSliceReply.success(slicingId, 100000, sendToProbe.ref()));

        assertFailureCallback(RuntimeException.class);

        assertFalse("MessageSlicer did not remove state for " + slicingId, slicer.hasState(slicingId));
        assertFalse("MessageAssembler did not remove state for " + slicingId, assembler.hasState(slicingId));
    }

    LOG.info("testSlicingWithMaxRetriesReached ending");
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSlicingWithFailure() {
    LOG.info("testSlicingWithFailure starting");

    final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });
    final int messageSliceSize = SerializationUtils.serialize(message).length / 2;
    try (MessageSlicer slicer = newMessageSlicer("testSlicingWithFailure", messageSliceSize)) {
        final boolean wasSliced = slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(),
                mockOnFailureCallback);/*from   w  w  w . java2s .  com*/
        assertTrue(wasSliced);

        MessageSlice sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);

        MessageSliceException failure = new MessageSliceException("mock failure",
                new IOException("mock IOException"));
        slicer.handleMessage(
                MessageSliceReply.failed(sliceMessage.getIdentifier(), failure, sendToProbe.ref()));

        assertFailureCallback(IOException.class);

        assertFalse("MessageSlicer did not remove state for " + sliceMessage.getIdentifier(),
                slicer.hasState(sliceMessage.getIdentifier()));
    }

    LOG.info("testSlicingWithFailure ending");
}

---

From source file:org.opendaylight.controller.cluster.messaging.MessageSlicingIntegrationTest.java

@Test
public void testSliceWithFileBackedOutputStream() throws IOException {
    LOG.info("testSliceWithFileBackedOutputStream starting");

    final BytesMessage message = new BytesMessage(new byte[] { 1, 2, 3 });
    FileBackedOutputStream fileBackedStream = FILE_BACKED_STREAM_FACTORY.newInstance();
    try (ObjectOutputStream out = new ObjectOutputStream(fileBackedStream)) {
        out.writeObject(message);// w  w w  .ja  va2s  .  c  o m
    }

    try (MessageSlicer slicer = newMessageSlicer("testSliceWithFileBackedOutputStream",
            SerializationUtils.serialize(message).length)) {
        slicer.slice(SliceOptions.builder().identifier(IDENTIFIER).fileBackedOutputStream(fileBackedStream)
                .sendTo(ACTOR_SYSTEM.actorSelection(sendToProbe.ref().path())).replyTo(replyToProbe.ref())
                .onFailureCallback(mockOnFailureCallback).build());

        final MessageSlice sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);
        assembler.handleMessage(sliceMessage, sendToProbe.ref());
        assertAssembledMessage(message, replyToProbe.ref());
    }

    LOG.info("testSliceWithFileBackedOutputStream ending");
}

---

From source file:org.opendaylight.controller.cluster.raft.behaviors.LeaderTest.java

@Test
public void testReplicationWithPayloadSizeThatExceedsThreshold() {
    logStart("testReplicationWithPayloadSizeThatExceedsThreshold");

    final int serializedSize = SerializationUtils.serialize(new AppendEntries(1, LEADER_ID, -1, -1,
            Arrays.asList(new SimpleReplicatedLogEntry(0, 1, new MockRaftActorContext.MockPayload("large"))), 0,
            -1, (short) 0)).length;
    final MockRaftActorContext.MockPayload largePayload = new MockRaftActorContext.MockPayload("large",
            serializedSize);// w  w w. j  av  a 2s .co m

    MockRaftActorContext leaderActorContext = createActorContextWithFollower();
    ((DefaultConfigParamsImpl) leaderActorContext.getConfigParams())
            .setHeartBeatInterval(new FiniteDuration(300, TimeUnit.MILLISECONDS));
    ((DefaultConfigParamsImpl) leaderActorContext.getConfigParams()).setSnapshotChunkSize(serializedSize - 50);
    leaderActorContext.setReplicatedLog(new MockRaftActorContext.MockReplicatedLogBuilder().build());
    leaderActorContext.setCommitIndex(-1);
    leaderActorContext.setLastApplied(-1);

    leader = new Leader(leaderActorContext);
    leaderActorContext.setCurrentBehavior(leader);

    // Send initial heartbeat reply so follower is marked active
    MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    leader.handleMessage(followerActor, new AppendEntriesReply(FOLLOWER_ID, -1, true, -1, -1, (short) 0));
    MessageCollectorActor.clearMessages(followerActor);

    // Send normal payload first to prime commit index.
    final long term = leaderActorContext.getTermInformation().getCurrentTerm();
    sendReplicate(leaderActorContext, term, 0);

    AppendEntries appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    assertEquals("Entries size", 1, appendEntries.getEntries().size());
    assertEquals("Entry getIndex", 0, appendEntries.getEntries().get(0).getIndex());

    leader.handleMessage(followerActor, new AppendEntriesReply(FOLLOWER_ID, term, true, 0, term, (short) 0));
    assertEquals("getCommitIndex", 0, leaderActorContext.getCommitIndex());
    MessageCollectorActor.clearMessages(followerActor);

    // Now send a large payload that exceeds the maximum size for a single AppendEntries - it should be sliced.
    sendReplicate(leaderActorContext, term, 1, largePayload);

    MessageSlice messageSlice = MessageCollectorActor.expectFirstMatching(followerActor, MessageSlice.class);
    assertEquals("getSliceIndex", 1, messageSlice.getSliceIndex());
    assertEquals("getTotalSlices", 2, messageSlice.getTotalSlices());

    final Identifier slicingId = messageSlice.getIdentifier();

    appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    assertEquals("getPrevLogIndex", 0, appendEntries.getPrevLogIndex());
    assertEquals("getPrevLogTerm", term, appendEntries.getPrevLogTerm());
    assertEquals("getLeaderCommit", -1, appendEntries.getLeaderCommit());
    assertEquals("Entries size", 0, appendEntries.getEntries().size());
    MessageCollectorActor.clearMessages(followerActor);

    // Initiate a heartbeat - it should send an empty AppendEntries since slicing is in progress.

    // Sleep for the heartbeat interval so AppendEntries is sent.
    Uninterruptibles.sleepUninterruptibly(
            leaderActorContext.getConfigParams().getHeartBeatInterval().toMillis(), TimeUnit.MILLISECONDS);

    leader.handleMessage(leaderActor, SendHeartBeat.INSTANCE);

    appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    assertEquals("getLeaderCommit", -1, appendEntries.getLeaderCommit());
    assertEquals("Entries size", 0, appendEntries.getEntries().size());
    MessageCollectorActor.clearMessages(followerActor);

    // Simulate the MessageSliceReply's and AppendEntriesReply from the follower.

    leader.handleMessage(followerActor, MessageSliceReply.success(slicingId, 1, followerActor));
    messageSlice = MessageCollectorActor.expectFirstMatching(followerActor, MessageSlice.class);
    assertEquals("getSliceIndex", 2, messageSlice.getSliceIndex());

    leader.handleMessage(followerActor, MessageSliceReply.success(slicingId, 2, followerActor));

    leader.handleMessage(followerActor, new AppendEntriesReply(FOLLOWER_ID, term, true, 1, term, (short) 0));

    MessageCollectorActor.clearMessages(followerActor);

    // Send another normal payload.

    sendReplicate(leaderActorContext, term, 2);

    appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    assertEquals("Entries size", 1, appendEntries.getEntries().size());
    assertEquals("Entry getIndex", 2, appendEntries.getEntries().get(0).getIndex());
    assertEquals("getLeaderCommit", 1, appendEntries.getLeaderCommit());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• »