Beispiel #1
0
  /**
   * Tests appending and reading to make sure data is written and the data read is consistent with
   * the data written.
   *
   * @throws IOException
   */
  @Test
  public void basicWriteAndReadTest() throws IOException {
    String segmentName = "log_current";
    LogSegment segment = getSegment(segmentName, STANDARD_SEGMENT_SIZE, true);
    try {
      assertEquals(
          "Name of segment is inconsistent with what was provided", segmentName, segment.getName());
      assertEquals(
          "Capacity of segment is inconsistent with what was provided",
          STANDARD_SEGMENT_SIZE,
          segment.getCapacityInBytes());
      assertEquals(
          "Start offset is not equal to header size",
          LogSegment.HEADER_SIZE,
          segment.getStartOffset());
      int writeSize = 100;
      byte[] buf = TestUtils.getRandomBytes(3 * writeSize);
      long writeStartOffset = segment.getStartOffset();
      // append with buffer
      int written = segment.appendFrom(ByteBuffer.wrap(buf, 0, writeSize));
      assertEquals("Size written did not match size of buffer provided", writeSize, written);
      assertEquals(
          "End offset is not as expected", writeStartOffset + writeSize, segment.getEndOffset());
      readAndEnsureMatch(segment, writeStartOffset, Arrays.copyOfRange(buf, 0, writeSize));

      // append with channel
      segment.appendFrom(
          Channels.newChannel(
              new ByteBufferInputStream(ByteBuffer.wrap(buf, writeSize, writeSize))),
          writeSize);
      assertEquals(
          "End offset is not as expected",
          writeStartOffset + 2 * writeSize,
          segment.getEndOffset());
      readAndEnsureMatch(
          segment, writeStartOffset + writeSize, Arrays.copyOfRange(buf, writeSize, 2 * writeSize));

      // use writeFrom
      segment.writeFrom(
          Channels.newChannel(
              new ByteBufferInputStream(ByteBuffer.wrap(buf, 2 * writeSize, writeSize))),
          segment.getEndOffset(),
          writeSize);
      assertEquals(
          "End offset is not as expected",
          writeStartOffset + 3 * writeSize,
          segment.getEndOffset());
      readAndEnsureMatch(
          segment,
          writeStartOffset + 2 * writeSize,
          Arrays.copyOfRange(buf, 2 * writeSize, buf.length));

      readAndEnsureMatch(segment, writeStartOffset, buf);
      // check file size and end offset (they will not match)
      assertEquals(
          "End offset is not equal to the cumulative bytes written",
          writeStartOffset + 3 * writeSize,
          segment.getEndOffset());
      assertEquals(
          "Size in bytes is not equal to size of the file",
          STANDARD_SEGMENT_SIZE,
          segment.sizeInBytes());

      // ensure flush doesn't throw any errors.
      segment.flush();
      // close and reopen segment and ensure persistence.
      segment.close();
      segment = new LogSegment(segmentName, new File(tempDir, segmentName), metrics);
      segment.setEndOffset(writeStartOffset + buf.length);
      readAndEnsureMatch(segment, writeStartOffset, buf);
    } finally {
      closeSegmentAndDeleteFile(segment);
    }
  }
Beispiel #2
0
 /**
  * Appends random data of size {@code size} to given {@code segment}.
  *
  * @param segment the {@link LogSegment} to append data to.
  * @param size the size of the data that should be appended.
  * @return the data that was appended.
  * @throws IOException
  */
 private byte[] appendRandomData(LogSegment segment, int size) throws IOException {
   byte[] buf = TestUtils.getRandomBytes(size);
   segment.appendFrom(ByteBuffer.wrap(buf));
   return buf;
 }