Limit filesize of a filestream? - c++

Question

My application currently logs in a very simple way:
void Log::create( const std::string& path, bool append )
{
if(append)
m_log.open(path.c_str(),std::ios_base::out | std::ios_base::app);
else
m_log.open(path.c_str(),std::ios_base::out | std::ios_base::trunc);
}
std::ofstream& Log::get()
{
return m_log;
}
void Log::write( const std::string& what )
{
get() << "[" << TimeOfDay::getDate() << "] ";
get() << what << std::endl;
}
void Log::write( const std::string& where, const std::string& what )
{
get() << "[" << TimeOfDay::getDate() << "] ";
get() << "[" << where << "] " << what << std::endl;
}
std::ofstream& Log::write()
{
get() << "[" << TimeOfDay::getDate() << "] ";
return get();
}
std::ofstream Log::m_log;
This application runs on a server. Now, if the log exceeds a certain file size, I want to stop logging.
Is there a way to do this without boost or other libraries?
Thanks

Answer 1

You can create a filtering stream buffer which is set up to write a file but stops writing if it has written more than a specified amount of data. Something like this:
class limitbuf
: public std::streambuf {
std::streambuf* sbuf;
size_t size;
size_t limit;
char buffer[1024];
public:
limitbuf(std::streambuf* sbuf, size_t limit)
: sbuf(sbuf), limit(limit), size(0)
{
this->setp(buffer, buffer + 1023);
}
int overflow(int c) {
if (c != std::char_traits<char>::eof()) {
this->pptr() = std::char_traits<char>::to_char_type(c);
this->pbump(1);
}
return this->sync() == 0
? std::char_traits<char>::not_eof(c)
: std::char_traits<char>::eof();
}
int sync() {
if (this->size < limit) {
this->size += this->sbuf->sputn(this->pbase(),
std::min(
size_t(this->pptr() - this->pbase()),
this->limit - this->size)
);
this->sbuf->pubsync();
}
this->setp(this->pbase(), this->epptr());
return 0;
}
};
Just install this stream buffer as a filter to your log file and it should be limiting to some suitable size:
std::ofstream out("some.log", 16384);
limitbuf sbuf(out.rdbuf());
std::ostream log(&sbuf);
The basic idea of this stream buffer is fairly simple: data is buffer internally and written upon a buffer overflow or upon a flush:
When the buffer set up with setp() overflows the stream calls overflow(c) with the next character to be written (or, potentially, with std::char_traits<char>::eof()). Since te stream buffer was told about a buffer one character smaller than actually available, the overflowing character is added to the buffer and the overall buffer is flushed.
When the buffer is flushed (e.g. by using std::endl on the std::ostream writing to this buffer) the function sync() ends up being called. Its just is to write the characters currently buffered. The code simply sees if there is still space for anything to be written and writes the character if there is space available. The size member maintains how many characters are written and limit is set up to indicate how much data is to be written.
If the stream buffer should do more than just limit the output, it may be necessary to modify the logic of what is happening if there is no more space. For example, if there are left-over characters which can't be written the stream buffer could decide to open a new file (and possibly move other files).