folly::RecordIOWriter Class Reference

#include <RecordIO.h>

Public Member Functions
	RecordIOWriter (File file, uint32_t fileId=1)
void	write (std::unique_ptr< IOBuf > buf)
off_t	filePos () const

Private Attributes
File	file_
uint32_t	fileId_
std::unique_lock< File >	writeLock_
std::atomic< off_t >	filePos_

Detailed Description

Class to write a stream of RecordIO records to a file.

RecordIOWriter is thread-safe

Definition at line 45 of file RecordIO.h.

Constructor & Destructor Documentation

folly::RecordIOWriter::RecordIOWriter ( File  file, uint32_t  fileId = 1  )

explicit

Create a RecordIOWriter around a file; will append to the end of file if it exists.

Each file must have a non-zero file id, which is embedded in all record headers. Readers will only return records with the requested file id (or, if the reader is created with fileId=0 in the constructor, the reader will return all records). File ids are only used to allow resynchronization if you store RecordIO records (with headers) inside other RecordIO records (for example, if a record consists of a fragment from another RecordIO file). If you're not planning to do that, the defaults are fine.

Definition at line 33 of file RecordIO.cpp.

References folly::checkUnixError(), folly::File::fd(), file_, filePos_, and writeLock_.

    : file_(std::move(file)),
      fileId_(fileId),
      writeLock_(file_, std::defer_lock),
      filePos_(0) {
  if (!writeLock_.try_lock()) {
    throw std::runtime_error("RecordIOWriter: file locked by another process");
  }

  struct stat st;
  checkUnixError(fstat(file_.fd(), &st), "fstat() failed");

  filePos_ = st.st_size;
}

Member Function Documentation

off_t folly::RecordIOWriter::filePos ( ) const

inline

Return the position in the file where the next byte will be written. Conservative, as stuff can be written at any time from another thread.

Definition at line 72 of file RecordIO.h.

References filePos_.

Referenced by folly::test::TEST().

                        {
    return filePos_;
  }

void folly::RecordIOWriter::write

(

std::unique_ptr< IOBuf >

buf

)

Write a record. We will use at most headerSize() bytes of headroom, you might want to arrange that before copying your data into it.

Definition at line 48 of file RecordIO.cpp.

References folly::checkUnixError(), folly::File::fd(), file_, fileId_, filePos_, folly::recordio_helpers::prependHeader(), folly::pwriteFull(), and folly::pwritevFull().

Referenced by folly::test::TEST().

                                                   {
  size_t totalLength = prependHeader(buf, fileId_);
  if (totalLength == 0) {
    return; // nothing to do
  }

  DCHECK_EQ(buf->computeChainDataLength(), totalLength);

  // We're going to write.  Reserve space for ourselves.
  off_t pos = filePos_.fetch_add(off_t(totalLength));

#if FOLLY_HAVE_PWRITEV
  auto iov = buf->getIov();
  ssize_t bytes = pwritevFull(file_.fd(), iov.data(), iov.size(), pos);
#else
  buf->unshare();
  buf->coalesce();
  ssize_t bytes = pwriteFull(file_.fd(), buf->data(), buf->length(), pos);
#endif

  checkUnixError(bytes, "pwrite() failed");
  DCHECK_EQ(size_t(bytes), totalLength);
}

Member Data Documentation

File folly::RecordIOWriter::file_

private

Definition at line 77 of file RecordIO.h.

Referenced by RecordIOWriter(), and write().

uint32_t folly::RecordIOWriter::fileId_

private

Definition at line 78 of file RecordIO.h.

Referenced by write().

std::atomic<off_t> folly::RecordIOWriter::filePos_

private

Definition at line 80 of file RecordIO.h.

Referenced by filePos(), RecordIOWriter(), and write().

std::unique_lock<File> folly::RecordIOWriter::writeLock_

private

Definition at line 79 of file RecordIO.h.

Referenced by RecordIOWriter().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/io/RecordIO.h
• proxygen/folly/folly/io/RecordIO.cpp