leveldb::log Namespace Reference

Classes
class	LogTest
class	Reader
class	Writer

Enumerations
enum	RecordType {   kZeroType = 0, kFullType = 1, kFirstType = 2, kMiddleType = 3,   kLastType = 4 }

Functions
static std::string	BigString (const std::string &partial_string, size_t n)
static std::string	NumberString (int n)
static std::string	RandomSkewedString (int i, Random *rnd)
	TEST (LogTest, Empty)
	TEST (LogTest, ReadWrite)
	TEST (LogTest, ManyBlocks)
	TEST (LogTest, Fragmentation)
	TEST (LogTest, MarginalTrailer)
	TEST (LogTest, MarginalTrailer2)
	TEST (LogTest, ShortTrailer)
	TEST (LogTest, AlignedEof)
	TEST (LogTest, OpenForAppend)
	TEST (LogTest, RandomRead)
	TEST (LogTest, ReadError)
	TEST (LogTest, BadRecordType)
	TEST (LogTest, TruncatedTrailingRecordIsIgnored)
	TEST (LogTest, BadLength)
	TEST (LogTest, BadLengthAtEndIsIgnored)
	TEST (LogTest, ChecksumMismatch)
	TEST (LogTest, UnexpectedMiddleType)
	TEST (LogTest, UnexpectedLastType)
	TEST (LogTest, UnexpectedFullType)
	TEST (LogTest, UnexpectedFirstType)
	TEST (LogTest, MissingLastIsIgnored)
	TEST (LogTest, PartialLastIsIgnored)
	TEST (LogTest, SkipIntoMultiRecord)
	TEST (LogTest, ErrorJoinsRecords)
	TEST (LogTest, ReadStart)
	TEST (LogTest, ReadSecondOneOff)
	TEST (LogTest, ReadSecondTenThousand)
	TEST (LogTest, ReadSecondStart)
	TEST (LogTest, ReadThirdOneOff)
	TEST (LogTest, ReadThirdStart)
	TEST (LogTest, ReadFourthOneOff)
	TEST (LogTest, ReadFourthFirstBlockTrailer)
	TEST (LogTest, ReadFourthMiddleBlock)
	TEST (LogTest, ReadFourthLastBlock)
	TEST (LogTest, ReadFourthStart)
	TEST (LogTest, ReadInitialOffsetIntoBlockPadding)
	TEST (LogTest, ReadEnd)
	TEST (LogTest, ReadPastEnd)
static void	InitTypeCrc (uint32_t *type_crc)

Variables
static const int	kMaxRecordType = kLastType
static const int	kBlockSize = 32768
static const int	kHeaderSize = 4 + 2 + 1

Enumeration Type Documentation

RecordType

enum leveldb::log::RecordType

Enumerator
kZeroType
kFullType
kFirstType
kMiddleType
kLastType

Definition at line 14 of file log_format.h.

                {
  // Zero is reserved for preallocated files
  kZeroType = 0,

  kFullType = 1,

  // For fragments
  kFirstType = 2,
  kMiddleType = 3,
  kLastType = 4
};

Function Documentation

BigString()

static std::string leveldb::log::BigString ( const std::string &  partial_string, size_t  n  )

static

Definition at line 18 of file log_test.cc.

                                                                      {
  std::string result;
  while (result.size() < n) {
    result.append(partial_string);
  }
  result.resize(n);
  return result;
}

Here is the caller graph for this function:

InitTypeCrc()

static void leveldb::log::InitTypeCrc ( uint32_t *  type_crc )

static

Definition at line 15 of file log_writer.cc.

                                            {
  for (int i = 0; i <= kMaxRecordType; i++) {
    char t = static_cast<char>(i);
    type_crc[i] = crc32c::Value(&t, 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumberString()

static std::string leveldb::log::NumberString ( int  n )

static

Definition at line 28 of file log_test.cc.

                                     {
  char buf[50];
  snprintf(buf, sizeof(buf), "%d.", n);
  return std::string(buf);
}

Here is the caller graph for this function:

RandomSkewedString()

static std::string leveldb::log::RandomSkewedString ( int  i, Random *  rnd  )

static

Definition at line 35 of file log_test.cc.

                                                        {
  return BigString(NumberString(i), rnd->Skewed(17));
}

Here is the call graph for this function:

Here is the caller graph for this function:

TEST() [1/38]

leveldb::log::TEST	(	LogTest	,
		Empty
	)

Definition at line 270 of file log_test.cc.

                     {
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [2/38]

leveldb::log::TEST	(	LogTest	,
		ReadWrite
	)

Definition at line 274 of file log_test.cc.

                         {
  Write("foo");
  Write("bar");
  Write("");
  Write("xxxx");
  ASSERT_EQ("foo", Read());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("", Read());
  ASSERT_EQ("xxxx", Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ("EOF", Read());  // Make sure reads at eof work
}

Here is the call graph for this function:

TEST() [3/38]

leveldb::log::TEST	(	LogTest	,
		ManyBlocks
	)

Definition at line 287 of file log_test.cc.

                          {
  for (int i = 0; i < 100000; i++) {
    Write(NumberString(i));
  }
  for (int i = 0; i < 100000; i++) {
    ASSERT_EQ(NumberString(i), Read());
  }
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [4/38]

leveldb::log::TEST	(	LogTest	,
		Fragmentation
	)

Definition at line 297 of file log_test.cc.

                             {
  Write("small");
  Write(BigString("medium", 50000));
  Write(BigString("large", 100000));
  ASSERT_EQ("small", Read());
  ASSERT_EQ(BigString("medium", 50000), Read());
  ASSERT_EQ(BigString("large", 100000), Read());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [5/38]

leveldb::log::TEST	(	LogTest	,
		MarginalTrailer
	)

Definition at line 307 of file log_test.cc.

                               {
  // Make a trailer that is exactly the same length as an empty record.
  const int n = kBlockSize - 2*kHeaderSize;
  Write(BigString("foo", n));
  ASSERT_EQ(kBlockSize - kHeaderSize, WrittenBytes());
  Write("");
  Write("bar");
  ASSERT_EQ(BigString("foo", n), Read());
  ASSERT_EQ("", Read());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [6/38]

leveldb::log::TEST	(	LogTest	,
		MarginalTrailer2
	)

Definition at line 320 of file log_test.cc.

                                {
  // Make a trailer that is exactly the same length as an empty record.
  const int n = kBlockSize - 2*kHeaderSize;
  Write(BigString("foo", n));
  ASSERT_EQ(kBlockSize - kHeaderSize, WrittenBytes());
  Write("bar");
  ASSERT_EQ(BigString("foo", n), Read());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(0, DroppedBytes());
  ASSERT_EQ("", ReportMessage());
}

Here is the call graph for this function:

TEST() [7/38]

leveldb::log::TEST	(	LogTest	,
		ShortTrailer
	)

Definition at line 333 of file log_test.cc.

                            {
  const int n = kBlockSize - 2*kHeaderSize + 4;
  Write(BigString("foo", n));
  ASSERT_EQ(kBlockSize - kHeaderSize + 4, WrittenBytes());
  Write("");
  Write("bar");
  ASSERT_EQ(BigString("foo", n), Read());
  ASSERT_EQ("", Read());
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [8/38]

leveldb::log::TEST	(	LogTest	,
		AlignedEof
	)

Definition at line 345 of file log_test.cc.

                          {
  const int n = kBlockSize - 2*kHeaderSize + 4;
  Write(BigString("foo", n));
  ASSERT_EQ(kBlockSize - kHeaderSize + 4, WrittenBytes());
  ASSERT_EQ(BigString("foo", n), Read());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [9/38]

leveldb::log::TEST	(	LogTest	,
		OpenForAppend
	)

Definition at line 353 of file log_test.cc.

                             {
  Write("hello");
  ReopenForAppend();
  Write("world");
  ASSERT_EQ("hello", Read());
  ASSERT_EQ("world", Read());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [10/38]

leveldb::log::TEST	(	LogTest	,
		RandomRead
	)

Definition at line 362 of file log_test.cc.

                          {
  const int N = 500;
  Random write_rnd(301);
  for (int i = 0; i < N; i++) {
    Write(RandomSkewedString(i, &write_rnd));
  }
  Random read_rnd(301);
  for (int i = 0; i < N; i++) {
    ASSERT_EQ(RandomSkewedString(i, &read_rnd), Read());
  }
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [11/38]

leveldb::log::TEST	(	LogTest	,
		ReadError
	)

Definition at line 377 of file log_test.cc.

                         {
  Write("foo");
  ForceError();
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(kBlockSize, DroppedBytes());
  ASSERT_EQ("OK", MatchError("read error"));
}

Here is the call graph for this function:

TEST() [12/38]

leveldb::log::TEST	(	LogTest	,
		BadRecordType
	)

Definition at line 385 of file log_test.cc.

                             {
  Write("foo");
  // Type is stored in header[6]
  IncrementByte(6, 100);
  FixChecksum(0, 3);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("unknown record type"));
}

Here is the call graph for this function:

TEST() [13/38]

leveldb::log::TEST	(	LogTest	,
		TruncatedTrailingRecordIsIgnored
	)

Definition at line 395 of file log_test.cc.

                                                {
  Write("foo");
  ShrinkSize(4);   // Drop all payload as well as a header byte
  ASSERT_EQ("EOF", Read());
  // Truncated last record is ignored, not treated as an error.
  ASSERT_EQ(0, DroppedBytes());
  ASSERT_EQ("", ReportMessage());
}

Here is the call graph for this function:

TEST() [14/38]

leveldb::log::TEST	(	LogTest	,
		BadLength
	)

Definition at line 404 of file log_test.cc.

                         {
  const int kPayloadSize = kBlockSize - kHeaderSize;
  Write(BigString("bar", kPayloadSize));
  Write("foo");
  // Least significant size byte is stored in header[4].
  IncrementByte(4, 1);
  ASSERT_EQ("foo", Read());
  ASSERT_EQ(kBlockSize, DroppedBytes());
  ASSERT_EQ("OK", MatchError("bad record length"));
}

Here is the call graph for this function:

TEST() [15/38]

leveldb::log::TEST	(	LogTest	,
		BadLengthAtEndIsIgnored
	)

Definition at line 415 of file log_test.cc.

                                       {
  Write("foo");
  ShrinkSize(1);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(0, DroppedBytes());
  ASSERT_EQ("", ReportMessage());
}

Here is the call graph for this function:

TEST() [16/38]

leveldb::log::TEST	(	LogTest	,
		ChecksumMismatch
	)

Definition at line 423 of file log_test.cc.

                                {
  Write("foo");
  IncrementByte(0, 10);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(10, DroppedBytes());
  ASSERT_EQ("OK", MatchError("checksum mismatch"));
}

Here is the call graph for this function:

TEST() [17/38]

leveldb::log::TEST	(	LogTest	,
		UnexpectedMiddleType
	)

Definition at line 431 of file log_test.cc.

                                    {
  Write("foo");
  SetByte(6, kMiddleType);
  FixChecksum(0, 3);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
}

Here is the call graph for this function:

TEST() [18/38]

leveldb::log::TEST	(	LogTest	,
		UnexpectedLastType
	)

Definition at line 440 of file log_test.cc.

                                  {
  Write("foo");
  SetByte(6, kLastType);
  FixChecksum(0, 3);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
}

Here is the call graph for this function:

TEST() [19/38]

leveldb::log::TEST	(	LogTest	,
		UnexpectedFullType
	)

Definition at line 449 of file log_test.cc.

                                  {
  Write("foo");
  Write("bar");
  SetByte(6, kFirstType);
  FixChecksum(0, 3);
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("partial record without end"));
}

Here is the call graph for this function:

TEST() [20/38]

leveldb::log::TEST	(	LogTest	,
		UnexpectedFirstType
	)

Definition at line 460 of file log_test.cc.

                                   {
  Write("foo");
  Write(BigString("bar", 100000));
  SetByte(6, kFirstType);
  FixChecksum(0, 3);
  ASSERT_EQ(BigString("bar", 100000), Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("partial record without end"));
}

Here is the call graph for this function:

TEST() [21/38]

leveldb::log::TEST	(	LogTest	,
		MissingLastIsIgnored
	)

Definition at line 471 of file log_test.cc.

                                    {
  Write(BigString("bar", kBlockSize));
  // Remove the LAST block, including header.
  ShrinkSize(14);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ("", ReportMessage());
  ASSERT_EQ(0, DroppedBytes());
}

Here is the call graph for this function:

TEST() [22/38]

leveldb::log::TEST	(	LogTest	,
		PartialLastIsIgnored
	)

Definition at line 480 of file log_test.cc.

                                    {
  Write(BigString("bar", kBlockSize));
  // Cause a bad record length in the LAST block.
  ShrinkSize(1);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ("", ReportMessage());
  ASSERT_EQ(0, DroppedBytes());
}

Here is the call graph for this function:

TEST() [23/38]

leveldb::log::TEST	(	LogTest	,
		SkipIntoMultiRecord
	)

Definition at line 489 of file log_test.cc.

                                   {
  // Consider a fragmented record:
  //    first(R1), middle(R1), last(R1), first(R2)
  // If initial_offset points to a record after first(R1) but before first(R2)
  // incomplete fragment errors are not actual errors, and must be suppressed
  // until a new first or full record is encountered.
  Write(BigString("foo", 3*kBlockSize));
  Write("correct");
  StartReadingAt(kBlockSize);

  ASSERT_EQ("correct", Read());
  ASSERT_EQ("", ReportMessage());
  ASSERT_EQ(0, DroppedBytes());
  ASSERT_EQ("EOF", Read());
}

Here is the call graph for this function:

TEST() [24/38]

leveldb::log::TEST	(	LogTest	,
		ErrorJoinsRecords
	)

Definition at line 505 of file log_test.cc.

                                 {
  // Consider two fragmented records:
  //    first(R1) last(R1) first(R2) last(R2)
  // where the middle two fragments disappear.  We do not want
  // first(R1),last(R2) to get joined and returned as a valid record.

  // Write records that span two blocks
  Write(BigString("foo", kBlockSize));
  Write(BigString("bar", kBlockSize));
  Write("correct");

  // Wipe the middle block
  for (int offset = kBlockSize; offset < 2*kBlockSize; offset++) {
    SetByte(offset, 'x');
  }

  ASSERT_EQ("correct", Read());
  ASSERT_EQ("EOF", Read());
  const size_t dropped = DroppedBytes();
  ASSERT_LE(dropped, 2*kBlockSize + 100);
  ASSERT_GE(dropped, 2*kBlockSize);
}

Here is the call graph for this function:

TEST() [25/38]

leveldb::log::TEST	(	LogTest	,
		ReadStart
	)

Definition at line 528 of file log_test.cc.

                         {
  CheckInitialOffsetRecord(0, 0);
}

Here is the call graph for this function:

TEST() [26/38]

leveldb::log::TEST	(	LogTest	,
		ReadSecondOneOff
	)

Definition at line 532 of file log_test.cc.

                                {
  CheckInitialOffsetRecord(1, 1);
}

Here is the call graph for this function:

TEST() [27/38]

leveldb::log::TEST	(	LogTest	,
		ReadSecondTenThousand
	)

Definition at line 536 of file log_test.cc.

                                     {
  CheckInitialOffsetRecord(10000, 1);
}

Here is the call graph for this function:

TEST() [28/38]

leveldb::log::TEST	(	LogTest	,
		ReadSecondStart
	)

Definition at line 540 of file log_test.cc.

                               {
  CheckInitialOffsetRecord(10007, 1);
}

Here is the call graph for this function:

TEST() [29/38]

leveldb::log::TEST	(	LogTest	,
		ReadThirdOneOff
	)

Definition at line 544 of file log_test.cc.

                               {
  CheckInitialOffsetRecord(10008, 2);
}

Here is the call graph for this function:

TEST() [30/38]

leveldb::log::TEST	(	LogTest	,
		ReadThirdStart
	)

Definition at line 548 of file log_test.cc.

                              {
  CheckInitialOffsetRecord(20014, 2);
}

Here is the call graph for this function:

TEST() [31/38]

leveldb::log::TEST	(	LogTest	,
		ReadFourthOneOff
	)

Definition at line 552 of file log_test.cc.

                                {
  CheckInitialOffsetRecord(20015, 3);
}

Here is the call graph for this function:

TEST() [32/38]

leveldb::log::TEST	(	LogTest	,
		ReadFourthFirstBlockTrailer
	)

Definition at line 556 of file log_test.cc.

                                           {
  CheckInitialOffsetRecord(log::kBlockSize - 4, 3);
}

Here is the call graph for this function:

TEST() [33/38]

leveldb::log::TEST	(	LogTest	,
		ReadFourthMiddleBlock
	)

Definition at line 560 of file log_test.cc.

                                     {
  CheckInitialOffsetRecord(log::kBlockSize + 1, 3);
}

Here is the call graph for this function:

TEST() [34/38]

leveldb::log::TEST	(	LogTest	,
		ReadFourthLastBlock
	)

Definition at line 564 of file log_test.cc.

                                   {
  CheckInitialOffsetRecord(2 * log::kBlockSize + 1, 3);
}

Here is the call graph for this function:

TEST() [35/38]

leveldb::log::TEST	(	LogTest	,
		ReadFourthStart
	)

Definition at line 568 of file log_test.cc.

                               {
  CheckInitialOffsetRecord(
      2 * (kHeaderSize + 1000) + (2 * log::kBlockSize - 1000) + 3 * kHeaderSize,
      3);
}

Here is the call graph for this function:

TEST() [36/38]

leveldb::log::TEST	(	LogTest	,
		ReadInitialOffsetIntoBlockPadding
	)

Definition at line 574 of file log_test.cc.

                                                 {
  CheckInitialOffsetRecord(3 * log::kBlockSize - 3, 5);
}

Here is the call graph for this function:

TEST() [37/38]

leveldb::log::TEST	(	LogTest	,
		ReadEnd
	)

Definition at line 578 of file log_test.cc.

                       {
  CheckOffsetPastEndReturnsNoRecords(0);
}

Here is the call graph for this function:

TEST() [38/38]

leveldb::log::TEST	(	LogTest	,
		ReadPastEnd
	)

Definition at line 582 of file log_test.cc.

                           {
  CheckOffsetPastEndReturnsNoRecords(5);
}

Here is the call graph for this function:

Variable Documentation

kBlockSize

const int leveldb::log::kBlockSize = 32768

static

Definition at line 27 of file log_format.h.

kHeaderSize

const int leveldb::log::kHeaderSize = 4 + 2 + 1

static

Definition at line 30 of file log_format.h.

kMaxRecordType

const int leveldb::log::kMaxRecordType = kLastType

static

Definition at line 25 of file log_format.h.