DiscardStream Class Reference

Simple class to just discard anything written to stream by redirecting it to /dev/null. More...

#include <IOIntercept.h>

Inheritance diagram for DiscardStream:

Collaboration diagram for DiscardStream:

Public Member Functions
	DiscardStream (std::ostream &stream, FILE *fileObject)
	Create StreamInterceptor which will redirect to /dev/null.
bool	start ()
	start intercepting the stream.
bool	finish ()
	stop intercepting the stream.

Protected Member Functions
void	setReplacementFD (int fd)
	set the replacement file descriptor, should be called in the constructor of derived classes
bool	replaceFD (int fileDescriptor)
	Replace the file descriptor of m_fileObject with the one passed.

Static Protected Member Functions
static void	readFD (int fd, std::string &out)
	Read the contents of a file descriptor until there is no more input and place them in out.

Protected Attributes
std::ostream &	m_stream
	C++ stream object, only needed to flush before replacement.
FILE *	m_fileObject
	File object of the file we want to replace, needed to obtain file descriptor and to flush.
int	m_savedFD { -1}
	Saved file descriptor: a duplicate of the file descriptor of m_fileObject.
int	m_replacementFD { -1}
	Replacement file descriptor to be used while capturing.
bool	m_capturing {false}
	Check whether we are already capturing.

Detailed Description

Simple class to just discard anything written to stream by redirecting it to /dev/null.

Definition at line 88 of file IOIntercept.h.

Constructor & Destructor Documentation

DiscardStream()

DiscardStream	(	std::ostream &	stream,
		FILE *	fileObject
	)

Create StreamInterceptor which will redirect to /dev/null.

Definition at line 145 of file IOIntercept.cc.

                                                                  : StreamInterceptor(stream, fileObject)
  {
    int devNull = open("/dev/null", O_WRONLY);
    if (devNull < 0) {
      // warning
      B2ERROR("Cannot open /dev/null: " << std::strerror(errno));
      return;
    }
    setReplacementFD(devNull);
  }

Member Function Documentation

finish()

bool finish ( )

inlineinherited

stop intercepting the stream.

Returns

true if the object was capturing and stream could be restored

Definition at line 46 of file IOIntercept.h.

      {
        if (!m_capturing) return false;
        m_capturing = false;
        return replaceFD(m_savedFD);
      }

readFD()

void readFD ( int  fd, std::string &  out  )

staticprotectedinherited

Read the contents of a file descriptor until there is no more input and place them in out.

Parameters

fd	file descriptor to read, should be opened in non blocking mode O_NOBLOCK
out	string to be replaced with all the bytes read from fd

Definition at line 102 of file IOIntercept.cc.

  {
    out.clear();
    if (fd <= 0) return;
    // need a buffer to read
    static std::unique_ptr<char[]> buffer(new char[1024]);
    // so then, read everything
    while (true) {
      ssize_t size = read(fd, buffer.get(), 1024);
      if (size <= 0) {
        // in case we get interrupted by signal, try again
        if (size < 0 && errno == EINTR)  continue;
        break;
      }
      out.append(buffer.get(), static_cast<size_t>(size));
    }
  }

replaceFD()

bool replaceFD ( int  fileDescriptor )

protectedinherited

Replace the file descriptor of m_fileObject with the one passed.

Parameters

fileDescriptor

file descriptor to be set for m_fileObject using dup2()

Definition at line 120 of file IOIntercept.cc.

  {
    // obviously we don't want to replace invalid descriptors
    if (fileDescriptor < 0) return false;
    // flush existing stream
    m_stream << std::flush;
    std::fflush(m_fileObject);
    // and clear the bad bits we might have gotten when pipe capacity is reached
    m_stream.clear();
    // and then replace the file descriptor
    const int currentFD = fileno(m_fileObject);
    if (currentFD < 0) {
      B2ERROR("Error obtaining file descriptor: " << std::strerror(errno));
      return false;
    }
    while (dup2(fileDescriptor, currentFD) < 0) {
      if (errno != EINTR && errno != EBUSY) {
        B2ERROR("Error in dup2(), cannot replace file descriptor: " << std::strerror(errno));
        return false;
      }
      // interrupted or busy, let's try again
    }
    return true;
  }

setReplacementFD()

void setReplacementFD ( int  fd )

inlineprotectedinherited

set the replacement file descriptor, should be called in the constructor of derived classes

Definition at line 54 of file IOIntercept.h.

{ m_replacementFD = fd; }

start()

bool start ( )

inlineinherited

start intercepting the stream.

Returns

true on success, false on any error

Definition at line 38 of file IOIntercept.h.

      {
        // only start if we are not already running
        if (!m_capturing) m_capturing = replaceFD(m_replacementFD);
        return m_capturing;
      }

Member Data Documentation

m_capturing

bool m_capturing {false}

protectedinherited

Check whether we are already capturing.

Definition at line 73 of file IOIntercept.h.

m_fileObject

FILE* m_fileObject

protectedinherited

File object of the file we want to replace, needed to obtain file descriptor and to flush.

Definition at line 67 of file IOIntercept.h.

m_replacementFD

int m_replacementFD { -1}

protectedinherited

Replacement file descriptor to be used while capturing.

Definition at line 71 of file IOIntercept.h.

m_savedFD

int m_savedFD { -1}

protectedinherited

Saved file descriptor: a duplicate of the file descriptor of m_fileObject.

Definition at line 69 of file IOIntercept.h.

m_stream

std::ostream& m_stream

protectedinherited

C++ stream object, only needed to flush before replacement.

Definition at line 65 of file IOIntercept.h.

---

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

• framework/utilities/include/IOIntercept.h
• framework/utilities/src/IOIntercept.cc