src/OutputCapturer.h

Go to the documentation of this file.

//
// C++ Interface: OutputCapturer
//
// Description: 
//
//
// Author: Roman Geus <geus@maxwell>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef OUTPUTCAPTURER_H
#define OUTPUTCAPTURER_H

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <string>
#include <sstream>

#include "rlog/rlog.h"
#include "rlog/RLogChannel.h"

class OutputCapturer {
public:
    OutputCapturer() :
        start_sig("---start marker---\n\n\n"),
        end_sig("--- end marker ---\n\n\n"),
        stream_redir_(stdout),
        fd_save_(-1)
    {
    }

    void begin_capture() {
        rAssert(fd_save_ == -1);
        int fd_redir = fileno(stream_redir_);

        // redirect stdout to file
        ::fflush(stream_redir_);
        ::fsync(fd_redir);
        fd_save_ = ::dup(fd_redir);
        rAssert(fd_save_ != -1);
        ::strcpy(capture_file_name_, "captXXXXXX");
        int fd_file = ::mkstemp(capture_file_name_);
        rAssert(fd_file != -1);
        ::close(fd_redir);
        int fd = ::dup(fd_file);
        rAssert(fd == fd_redir);
        ::close(fd_file);

        // write start signature
        int ret = ::write(fd_redir, start_sig, ::strlen(start_sig));
        rAssert(ret == static_cast<int>(::strlen(start_sig)));
    }

    void end_capture() {
        rAssert(fd_save_ != -1);
        int fd_redir = fileno(stream_redir_);

        // flush file stream buffer to disk
        ::fflush(stream_redir_);

        // write end signature
        int ret = ::write(fd_redir, end_sig, ::strlen(start_sig));
        rAssert(ret == static_cast<int>(::strlen(end_sig)));
        ::fsync(fd_redir);

        // revert redirection
        ::close(fd_redir);            /* close file */
        int fd = ::dup(fd_save_);          /* reinstall old stdout */
        rAssert(fd == fd_redir);
        ::close(fd_save_);             /* free duplicate fd */
        fd_save_ = -1;

        // read capture file into string buffer
        std::ifstream infile(capture_file_name_);
        stdout_buf_.str("");
        int ch;
        while ((ch = infile.get()) != EOF)
            stdout_buf_.put(ch);
        infile.close();

        // verify captured data


        // delete capture file
        ::unlink(capture_file_name_);
    }

    std::string get_stdout() const {
        rAssert(fd_save_ == -1);
        std::string str = stdout_buf_.str();
        rAssert(str.substr(0, ::strlen(start_sig)) == start_sig);
        rAssert(str.substr(str.size() - ::strlen(end_sig), ::strlen(end_sig)) == end_sig);
        std::string payload(str,
                            ::strlen(start_sig),
                            str.size() - ::strlen(start_sig) - ::strlen(end_sig));
        return payload;
    }

    std::string get_stderr() const {
        rAssert(false);
        return "";
    }

    void log(std::string prefix, rlog::RLogChannel* channel) {
        std::string msg(prefix + std::string(":\n") + get_stdout());
        rLog(channel, "%s", msg.c_str());
    }

protected:
    std::string get_temp_file_name() {
        return "zoltan.out";
    }

private:
    const char* start_sig;
    const char* end_sig;
    FILE* stream_redir_;
    char capture_file_name_[10];
    int fd_save_;
    std::ostringstream stdout_buf_;
};

#endif

---