Merge lp:~thumper/nux/rolling-file-appender into lp:nux

[Tim Penhey]

This branch adds a RollingFileAppender. It derives from std::ostream& and is
intended to be used with the logging code.

The RollingFileAppender is constructed with a full path filename, and
optionally a number of backup files and maximum log size.

Every time the stream is flushed, it checks the size of the file, and if
necessary, it closes the existing file, rolls the backups[1], and opens a new
file.

This change brings in the boost filesystem shared object library. It is 80k,
but I believe that it simplifies our filesystem handling and should be used.

The tests are found in tests/test_rolling_file_appender.cpp. The test uses a
fixture that has setup and teardown methods that make sure that the temp
directory doesn't exist prior to running the tests, and to clean up after
itself.

[1] Rolling means deleting the last log file if we have reached our limit on
the number of backup files, and renaming logfile.x to logfile.x+1, and finally
renaming logfile to logfile.1.

[lp:~thumper/nux/rolling-file-appender]

398. By Tim Penhey on 2011-06-23

Found that I can simplify at least some of the tests.

[Mirco Müller (macslow)]

Trying to compile nux with this branch merged led to this error...

make[2]: Betrete Verzeichnis '/tmp/bla/nux/examples'
  CXXLD button
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::remove_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::system::get_system_category()'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::status_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, boost::system::error_code&)'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::file_size_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::create_directory_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::system::get_generic_category()'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::symlink_status_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, boost::system::error_code&)'
../NuxCore/.libs/libnux-core-1.0.so: undefined reference to `boost::filesystem::detail::rename_api(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'
collect2: ld returned 1 exit status

review: Needs Fixing

[Tim Penhey (thumper)]

On Thu, 30 Jun 2011 13:11:12 you wrote:
> Review: Needs Fixing
> Trying to compile nux with this branch merged led to this error...

This branch is going to have hacked somewhat for gio stuff :) So is the remove
NFileName branch

[lp:~thumper/nux/rolling-file-appender]

399. By Tim Penhey on 2011-07-07

Initial declaration for the async file writer.

400. By Tim Penhey on 2011-07-07

Make the rolling file appender not depend on boost filesystem. Damn tests don't link though.

401. By Tim Penhey on 2011-07-11

Make the tests pass with the gio based rolling file appender.

402. By Tim Penhey on 2011-07-12

Framework of the async file writer and a failing test.

403. By Tim Penhey on 2011-07-13

Closer to working code now...

404. By Tim Penhey on 2011-07-13

Trying to figure out why it isn't creating the file.

405. By Tim Penhey on 2011-07-14

Tests should work, but they don't always.

406. By Tim Penhey on 2011-07-14

Async writer now seems to work.

407. By Tim Penhey on 2011-07-15

More ignores :(

408. By Tim Penhey on 2011-07-15

Merge trunk.

409. By Tim Penhey on 2011-07-15

Change the RollingFileAppender so it writes to the files asynchronously.

410. By Tim Penhey on 2011-07-15

Emit a signal when the files are rolled. Primarily for testing, but you never know.

411. By Tim Penhey on 2011-07-15

Update the rolling file appender tests.

[Tim Penhey (thumper)]

Hi Guys,

This is finally ready to have another look. I've kept the boost filesystem use, but only for the test suite. It allows for a secondary way to confirm that the files and directories and correct in the tests.

The RollingFileAppender now writes the log files out asynchronously using gio which is handled by the AsyncFileWriter class.

Due to the async nature, it was a PITA to test. I've added comments explaining the weirdness in the tests.

[Mirco Müller (macslow)]

After going through this again (this early in the morning) my brain hurts... but approved now :)

review: Approve

[Neil J. Patel (njpatel)]

Looks good and works well, nice one!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-06-30 13:26:34 +0000
+++ .bzrignore	2011-07-15 04:02:32 +0000
@@ -58,5 +58,7 @@
 tests/gtest-nux-core
 tests/test-nux
 tests/test-nux-results.xml
-
-
+tests/relative
+Logs
+**/nux.log
+**/nux.log.*

=== modified file 'Nux/Makefile.am'
--- Nux/Makefile.am	2011-06-30 13:26:34 +0000
+++ Nux/Makefile.am	2011-07-15 04:02:32 +0000
@@ -23,7 +23,7 @@
   $(NUX_LIBS)
 
 libnux_@NUX_API_VERSION@_la_LDFLAGS = \
-  $(NUX_LT_LDFLAGS)
+  $(NUX_LT_LDFLAGS) -lboost_filesystem
 
 source_cpp = \
   $(srcdir)/PropertyItem/CheckBoxProperty.cpp \

=== added file 'NuxCore/AsyncFileWriter.cpp'
--- NuxCore/AsyncFileWriter.cpp	1970-01-01 00:00:00 +0000
+++ NuxCore/AsyncFileWriter.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,246 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+
+#include "AsyncFileWriter.h"
+
+#include <sstream>
+
+#include <gio/gio.h>
+
+#include <iostream>
+
+namespace nux
+{
+
+/**
+ * CAUTION: right now this class is not thread aware.  It assumes that all the
+ * write calls are coming from a single thread.  Perhaps we need to fix this?
+ */
+class AsyncFileWriter::Impl
+{
+public:
+  Impl(AsyncFileWriter* owner, std::string const& filename);
+  ~Impl();
+
+  void Write(std::string const& data);
+  void Close();
+
+  void ProcessAsync();
+
+  static void AppendAsyncCallback(GFile* source, GAsyncResult* res, Impl* impl);
+  static void WriteAsyncCallback(GOutputStream* source, GAsyncResult* res, Impl* impl);
+  static void CloseAsyncCallback(GOutputStream* source, GAsyncResult* res, Impl* impl);
+
+  AsyncFileWriter* owner_;
+  GCancellable* cancel_;
+  GFile* file_;
+  GFileOutputStream* output_stream_;
+  bool close_pending_;
+  bool pending_async_call_;
+
+  std::stringstream pending_content_;
+  std::string data_to_write_;
+};
+
+
+AsyncFileWriter::Impl::Impl(AsyncFileWriter* owner, std::string const& filename)
+  : owner_(owner)
+  , cancel_(g_cancellable_new())
+  , file_(g_file_new_for_path(filename.c_str()))
+  , output_stream_(0)
+  , close_pending_(false)
+  , pending_async_call_(true)
+{
+  g_file_append_to_async(file_,
+                         G_FILE_CREATE_NONE,
+                         G_PRIORITY_DEFAULT,
+                         cancel_,
+                         (GAsyncReadyCallback)&AsyncFileWriter::Impl::AppendAsyncCallback,
+                         this);
+}
+
+AsyncFileWriter::Impl::~Impl()
+{
+  if (pending_async_call_)
+  {
+    g_cancellable_cancel(cancel_);
+  }
+  // make sure the file is closed.
+  if (output_stream_)
+  {
+    // If we had an output stream, sync write any pending content.
+    if (pending_content_.tellp())
+    {
+      std::string data(pending_content_.str());
+      gsize bytes_written;
+      g_output_stream_write_all((GOutputStream*)output_stream_,
+                                data.c_str(),
+                                data.size(),
+                                &bytes_written,
+                                NULL, NULL);
+    }
+    owner_->closed.emit();
+    g_object_unref(output_stream_);
+  }
+
+  g_object_unref(file_);
+  g_object_unref(cancel_);
+}
+
+void AsyncFileWriter::Impl::AppendAsyncCallback(GFile* source,
+                                                GAsyncResult* res,
+                                                Impl* impl)
+{
+  GError* error = NULL;
+  GFileOutputStream* stream = g_file_append_to_finish(source, res, &error);
+  if (error) {
+    // Cancelled callbacks call back, but have a cancelled error code.
+    if (error->code != G_IO_ERROR_CANCELLED) {
+      std::cerr << error->message << "\n";
+    }
+    g_error_free(error);
+    return;
+  }
+  impl->output_stream_ = stream;
+  impl->pending_async_call_ = false;
+  impl->owner_->opened.emit();
+  impl->ProcessAsync();
+}
+
+void AsyncFileWriter::Impl::Write(std::string const& data)
+{
+  if (close_pending_) return;
+  // TODO: lock the pending_content_ access
+  pending_content_ << data;
+  ProcessAsync();
+}
+
+void AsyncFileWriter::Impl::ProcessAsync()
+{
+  if (output_stream_ == NULL || pending_async_call_) return;
+
+  if (pending_content_.tellp())
+  {
+    // TODO: lock the pending_content_ access
+    data_to_write_ = pending_content_.str();
+    g_output_stream_write_async((GOutputStream*)output_stream_,
+                                data_to_write_.c_str(),
+                                data_to_write_.size(),
+                                G_PRIORITY_DEFAULT,
+                                cancel_,
+                                (GAsyncReadyCallback)&AsyncFileWriter::Impl::WriteAsyncCallback,
+                                this);
+    pending_async_call_ = true;
+  }
+  else if (close_pending_)
+  {
+    g_output_stream_close_async((GOutputStream*)output_stream_,
+                                G_PRIORITY_DEFAULT,
+                                cancel_,
+                                (GAsyncReadyCallback)&AsyncFileWriter::Impl::CloseAsyncCallback,
+                                this);
+    pending_async_call_ = true;
+  }
+}
+
+void AsyncFileWriter::Impl::WriteAsyncCallback(GOutputStream* source,
+                                               GAsyncResult* res,
+                                               Impl* impl)
+{
+  GError* error = NULL;
+  gssize g_bytes_written = g_output_stream_write_finish(source, res, &error);
+  if (error) {
+    // Cancelled callbacks call back, but have a cancelled error code.
+    if (error->code != G_IO_ERROR_CANCELLED) {
+      std::cerr << error->message << "\n";
+    }
+    g_error_free(error);
+    return;
+  }
+  // g_bytes_written is signed from gio, but only negative if there is an error.
+  // The error should be set too if there was an error, so no negative bytes
+  // written get past here.
+  std::size_t bytes_written = g_bytes_written;
+  impl->pending_async_call_ = false;
+  // TODO: lock the pending_content_ access
+  std::string data = impl->pending_content_.str();
+  if (bytes_written >= data.size()) {
+    // There should be no reason why bytes_written should be greater than the
+    // number of bytes in the stream, but this is paranoia.
+    impl->pending_content_.str("");
+  } else {
+    impl->pending_content_.str(data.substr(bytes_written));
+  }
+  impl->ProcessAsync();
+}
+
+void AsyncFileWriter::Impl::Close()
+{
+  close_pending_ = true;
+  ProcessAsync();
+}
+
+void AsyncFileWriter::Impl::CloseAsyncCallback(GOutputStream* source,
+                                               GAsyncResult* res,
+                                               Impl* impl)
+{
+  GError* error = NULL;
+  g_output_stream_close_finish(source, res, &error);
+  if (error) {
+    // Cancelled callbacks call back, but have a cancelled error code.
+    if (error->code != G_IO_ERROR_CANCELLED) {
+      std::cerr << error->message << "\n";
+    }
+    g_error_free(error);
+    return;
+  }
+  g_object_unref(impl->output_stream_);
+  impl->output_stream_ = 0;
+  impl->owner_->closed.emit();
+}
+
+AsyncFileWriter::AsyncFileWriter(std::string const& filename)
+  : pimpl(new Impl(this, filename))
+{}
+
+AsyncFileWriter::~AsyncFileWriter()
+{
+  delete pimpl;
+}
+
+void AsyncFileWriter::Write(std::string const& data)
+{
+  pimpl->Write(data);
+}
+
+void AsyncFileWriter::Close()
+{
+  pimpl->Close();
+}
+
+bool AsyncFileWriter::IsClosing() const
+{
+  return pimpl->close_pending_;
+}
+
+
+} // namespace nux

=== added file 'NuxCore/AsyncFileWriter.h'
--- NuxCore/AsyncFileWriter.h	1970-01-01 00:00:00 +0000
+++ NuxCore/AsyncFileWriter.h	2011-07-15 04:02:32 +0000
@@ -0,0 +1,63 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+#ifndef NUXCORE_ASYNC_FILE_WRITER_H
+#define NUXCORE_ASYNC_FILE_WRITER_H
+
+#include <string>
+#include <sigc++/sigc++.h>
+
+namespace nux
+{
+
+/**
+ * Write to a file asynchronously.
+ *
+ * This uses the GIO async functions, and as such depend on the gobject main
+ * loop.
+ */
+class AsyncFileWriter
+{
+public:
+  AsyncFileWriter(std::string const& filename);
+  // Destructor kills any pending async requests, and close the file
+  // synchronously if it is open.
+  ~AsyncFileWriter();
+
+  // Queue the data for writing.  It'll happen some time.
+  void Write(std::string const& data);
+  // Close the file asynchronously.  When the file is closed, the closed
+  // signal is emitted.
+  void Close();
+
+  bool IsClosing() const;
+
+  sigc::signal<void> opened;
+  sigc::signal<void> closed;
+
+private:
+  class Impl;
+  Impl* pimpl;
+};
+
+}
+
+#endif

=== modified file 'NuxCore/Makefile.am'
--- NuxCore/Makefile.am	2011-06-20 22:57:47 +0000
+++ NuxCore/Makefile.am	2011-07-15 04:02:32 +0000
@@ -25,6 +25,7 @@
   $(NUX_LT_LDFLAGS)
 
 source_cpp = \
+  $(srcdir)/AsyncFileWriter.cpp \
   $(srcdir)/TextString.cpp \
   $(srcdir)/TimeFunctions.cpp \
   $(srcdir)/Template.cpp \
@@ -80,6 +81,7 @@
   $(srcdir)/Math/Vector3.cpp \
   $(srcdir)/Math/Line3D.cpp \
   $(srcdir)/Math/Vector2.cpp \
+  $(srcdir)/RollingFileAppender.cpp \
   $(srcdir)/CRC32.cpp \
   $(srcdir)/InitiallyUnownedObject.cpp
 
@@ -126,6 +128,7 @@
   $(srcdir)/SmartPtr/GenericSmartPointer.h
 
 source_h = \
+  $(srcdir)/AsyncFileWriter.h \
   $(srcdir)/SystemTypes.h \
   $(srcdir)/Point.h \
   $(srcdir)/CPU.h \
@@ -141,6 +144,7 @@
   $(srcdir)/Colors.h \
   $(srcdir)/Logger.h \
   $(srcdir)/LoggingWriter.h \
+  $(srcdir)/RollingFileAppender.h \
   $(srcdir)/Memory.h \
   $(srcdir)/Error.h \
   $(srcdir)/SystemGNU.h \

=== added file 'NuxCore/RollingFileAppender.cpp'
--- NuxCore/RollingFileAppender.cpp	1970-01-01 00:00:00 +0000
+++ NuxCore/RollingFileAppender.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,231 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+
+#include "RollingFileAppender.h"
+
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+
+#include <gio/gio.h>
+
+#include <boost/lexical_cast.hpp>
+
+#include "AsyncFileWriter.h"
+
+namespace nux {
+namespace logging {
+
+namespace {
+
+std::string backup_path(std::string const& path, unsigned number)
+{
+  if (number == 0)
+    return path;
+
+  std::ostringstream sout;
+  sout << path << "." << number;
+  return sout.str();
+}
+
+// Change the implementation to string buf
+// Have a GFile representing the file on disk
+// g_file_append gives a GFileOutputStream (subclass of GOutputStream)
+// g_output_stream_write_async (only have one in progress at a time)
+// g_output_stream_flush_async (probably don't want a pending async)
+// keep our own count of the written bytes.
+// Tests don't have a g_object main loop, so we have another way...
+// while (g_main_context_pending(g_main_context_get_thread_default())) {
+//   g_main_context_iteration(g_main_context_get_thread_default());
+// }
+class RollingFileStreamBuffer : public std::stringbuf
+{
+public:
+  RollingFileStreamBuffer(std::string const& filename,
+                          unsigned number_of_backup_files,
+                          unsigned long long max_log_size,
+                          sigc::signal<void>& files_rolled);
+  ~RollingFileStreamBuffer();
+protected:
+  virtual int sync();
+private:
+  void AsyncWriterClosed();
+  void RotateFiles();
+
+  std::shared_ptr<AsyncFileWriter> writer_;
+  GFile* log_file_;
+  std::string filename_;
+  unsigned number_of_backup_files_;
+  unsigned long long max_log_size_;
+  unsigned long long bytes_written_;
+  sigc::connection writer_closed_;
+  sigc::signal<void>& files_rolled_;
+};
+
+RollingFileStreamBuffer::RollingFileStreamBuffer(std::string const& filename,
+                                                 unsigned number_of_backup_files,
+                                                 unsigned long long max_log_size,
+                                                 sigc::signal<void>& files_rolled)
+  : filename_(filename)
+  , number_of_backup_files_(number_of_backup_files)
+  , max_log_size_(max_log_size)
+  , bytes_written_(0)
+  , files_rolled_(files_rolled)
+{
+  // Make sure that the filename starts with a '/' for a full path.
+  if (filename.empty() || filename[0] != '/') {
+      std::string error_msg = "\"" + filename + "\" is not a full path";
+      throw std::runtime_error(error_msg.c_str());
+  }
+  // Looks to see if our filename exists.
+  if (g_file_test(filename.c_str(), G_FILE_TEST_EXISTS)) {
+    // The filename needs to be a regular file.
+    if (!g_file_test(filename.c_str(), G_FILE_TEST_IS_REGULAR)) {
+      std::string error_msg = filename + " is not a regular file";
+      throw std::runtime_error(error_msg.c_str());
+    }
+    // Rotate the files.
+    RotateFiles();
+  } else {
+    GFile* log_file = g_file_new_for_path(filename.c_str());
+    GFile* log_dir = g_file_get_parent(log_file);
+    if (log_dir) {
+      g_file_make_directory_with_parents(log_dir, NULL, NULL);
+      g_object_unref(log_dir);
+      g_object_unref(log_file);
+    }
+    else {
+      g_object_unref(log_file);
+      std::string error_msg = "Can't get parent for " + filename;
+      throw std::runtime_error(error_msg.c_str());
+    }
+  }
+  // Now open the filename.
+  writer_.reset(new AsyncFileWriter(filename));
+  log_file_ = g_file_new_for_path(filename_.c_str());
+}
+
+RollingFileStreamBuffer::~RollingFileStreamBuffer()
+{
+  // We don't want notification when the writer closes now.
+  if (writer_closed_.connected())
+    writer_closed_.disconnect();
+  g_object_unref(log_file_);
+}
+
+void RollingFileStreamBuffer::RotateFiles()
+{
+  // If we aren't keeping backups, no rolling needed.
+  if (number_of_backup_files_ == 0)
+    return;
+
+  unsigned backup = number_of_backup_files_;
+  std::string last_log(backup_path(filename_, backup));
+  if (g_file_test(last_log.c_str(), G_FILE_TEST_EXISTS)) {
+    // Attempt to remove it.
+    GFile* logfile = g_file_new_for_path(last_log.c_str());
+    g_file_delete(logfile, NULL, NULL);
+    g_object_unref(logfile);
+  }
+  // Move the previous files out.
+  while (backup > 0) {
+    std::string prev_log(backup_path(filename_, --backup));
+    if (g_file_test(prev_log.c_str(), G_FILE_TEST_EXISTS)) {
+      GFile* dest = g_file_new_for_path(last_log.c_str());
+      GFile* src = g_file_new_for_path(prev_log.c_str());
+      // We don't really care if there are errors for now.
+      g_file_move(src, dest, G_FILE_COPY_NONE, NULL, NULL, NULL, NULL);
+      g_object_unref(src);
+      g_object_unref(dest);
+    }
+    last_log = prev_log;
+  }
+}
+
+void RollingFileStreamBuffer::AsyncWriterClosed()
+{
+  // Rotate the files and open a new file writer.
+  RotateFiles();
+  writer_.reset(new AsyncFileWriter(filename_));
+  bytes_written_ = 0;
+  // We emit the files_rolled_ here and not in the RotateFiles method as the
+  // RotateFiles is called from the constructor, which has a reference to the
+  // files_rolled signal from the parent stream.  If this is emitted due
+  // rotating the files in the contructor, we get a seg fault due to trying to
+  // use the signal before it is constructed.
+  files_rolled_.emit();
+}
+
+int RollingFileStreamBuffer::sync()
+{
+  // If the async file writer is in the middle of closing, there is nothing we can do.
+  if (writer_->IsClosing())
+    return 0;
+
+  std::string message = str();
+  // reset the stream
+  str("");
+
+  std::size_t message_size = message.size();
+  if (message_size > 0)
+  {
+    bytes_written_ += message_size;
+    writer_->Write(message);
+    if (bytes_written_ > max_log_size_)
+    {
+      // Close the writer and once it is closed, rotate the files and open a new file.
+      writer_closed_ = writer_->closed.connect(
+        sigc::mem_fun(this, &RollingFileStreamBuffer::AsyncWriterClosed));
+      writer_->Close();
+    }
+  }
+  return 0; // success
+}
+
+} // anon namespace
+
+RollingFileAppender::RollingFileAppender(std::string const& filename)
+  : std::ostream(new RollingFileStreamBuffer(filename, 5, 1e7, files_rolled))
+{
+}
+
+RollingFileAppender::RollingFileAppender(std::string const& filename,
+                                         unsigned number_of_backup_files,
+                                         unsigned long long max_log_size)
+  : std::ostream(new RollingFileStreamBuffer(filename,
+                                             number_of_backup_files,
+                                             max_log_size,
+                                             files_rolled))
+{
+}
+
+RollingFileAppender::~RollingFileAppender()
+{
+  rdbuf()->pubsync();
+  std::streambuf* buff = rdbuf(0);
+  delete buff;
+}
+
+
+} // namespace logging
+} // namespace nux

=== added file 'NuxCore/RollingFileAppender.h'
--- NuxCore/RollingFileAppender.h	1970-01-01 00:00:00 +0000
+++ NuxCore/RollingFileAppender.h	2011-07-15 04:02:32 +0000
@@ -0,0 +1,48 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+#ifndef NUX_CORE_ROLLING_FILE_APPENDER_H
+#define NUX_CORE_ROLLING_FILE_APPENDER_H
+
+#include <ostream>
+#include <string>
+
+#include <sigc++/sigc++.h>
+
+namespace nux {
+namespace logging {
+
+class RollingFileAppender : public std::ostream
+{
+public:
+  RollingFileAppender(std::string const& filename);
+  RollingFileAppender(std::string const& filename,
+                      unsigned number_of_backup_files,
+                      unsigned long long max_log_size);
+  ~RollingFileAppender();
+
+  sigc::signal<void> files_rolled;
+};
+
+}
+}
+
+#endif

=== modified file 'configure.ac'
--- configure.ac	2011-07-13 10:22:48 +0000
+++ configure.ac	2011-07-15 04:02:32 +0000
@@ -110,7 +110,7 @@
 
 dnl ===========================================================================
 
-PKG_CHECK_MODULES(NUX_CORE, glib-2.0 >= 2.25.14 gthread-2.0 sigc++-2.0)
+PKG_CHECK_MODULES(NUX_CORE, glib-2.0 >= 2.25.14 gthread-2.0 sigc++-2.0 gio-2.0)
 AC_SUBST(NUX_CORE_CFLAGS)
 AC_SUBST(NUX_CORE_LIBS)
 

=== added file 'tests/Helpers.cpp'
--- tests/Helpers.cpp	1970-01-01 00:00:00 +0000
+++ tests/Helpers.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,52 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+
+#include "Helpers.h"
+
+#include <fstream>
+#include <stdexcept>
+
+namespace nux
+{
+namespace testing
+{
+
+std::string ReadFile(std::string const& filename)
+{
+  std::ifstream input(filename.c_str());
+  if (input.bad())
+    throw std::runtime_error("bad file");
+  return std::string((std::istreambuf_iterator<char>(input)),
+                     std::istreambuf_iterator<char>());
+}
+
+void PumpGObjectMainLoop()
+{
+  GMainContext* context(g_main_context_get_thread_default());
+  while (g_main_context_pending(context)) {
+    g_main_context_iteration(context, false);
+  }
+}
+
+
+}
+}

=== added file 'tests/Helpers.h'
--- tests/Helpers.h	1970-01-01 00:00:00 +0000
+++ tests/Helpers.h	2011-07-15 04:02:32 +0000
@@ -0,0 +1,63 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2011 Inalogic® Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Tim Penhey <[e-mail]>
+ *
+ */
+#ifndef NUX_TESTS_FILE_HELPERS_H
+#define NUX_TESTS_FILE_HELPERS_H
+
+#include <string>
+#include <glib.h>
+#include <sigc++/sigc++.h>
+
+
+namespace nux
+{
+namespace testing
+{
+
+std::string ReadFile(std::string const& filename);
+void PumpGObjectMainLoop();
+
+class TestCallback
+{
+public:
+  TestCallback() : happened(false) {}
+
+  sigc::slot<void> sigc_callback() {
+    return sigc::mem_fun(this, &TestCallback::callback);
+  }
+
+  static gboolean glib_callback(gpointer data) {
+    TestCallback* test = reinterpret_cast<TestCallback*>(data);
+    test->callback();
+    return FALSE;
+  }
+  void callback() {
+    happened = true;
+  }
+
+  bool happened;
+};
+
+
+}
+}
+
+#endif

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2011-06-24 14:49:09 +0000
+++ tests/Makefile.am	2011-07-15 04:02:32 +0000
@@ -33,8 +33,12 @@
   $(NUX_LIBS)
 
 gtest_nux_core_SOURCES = \
+  Helpers.cpp \
+  test_main.cpp \
+  test_async_file_writer.cpp \
   test_logger.cpp \
-  test_properties.cpp
+  test_properties.cpp \
+  test_rolling_file_appender.cpp
 
 gtest_nux_core_CPPFLAGS = \
   -I$(srcdir) \
@@ -55,7 +59,8 @@
   $(NUX_LIBS)
 
 gtest_nux_core_LDFLAGS = \
-  -lpthread -lgtest -lgtest_main -lgmock
+  -lpthread -lgtest -lgmock \
+  -lboost_filesystem -lboost_system
 
 
 #run make test as part of make check

=== added file 'tests/test_async_file_writer.cpp'
--- tests/test_async_file_writer.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_async_file_writer.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,110 @@
+#include <string>
+#include <fstream>
+
+#include <iostream>
+
+#include <gmock/gmock.h>
+
+#include <boost/filesystem.hpp>
+
+#include <glib.h>
+
+#include "NuxCore/AsyncFileWriter.h"
+
+#include "Helpers.h"
+
+namespace bf = boost::filesystem;
+using namespace testing;
+using namespace nux::testing;
+
+namespace {
+
+const std::string TEST_ROOT("/tmp/nux-test-cases");
+
+
+class TestAsyncfileWriter : public ::testing::Test
+{
+protected:
+  virtual void SetUp() {
+    // Make sure that the tests start with and empty TEST_ROOT.
+    bf::remove_all(TEST_ROOT);
+    bf::create_directories(TEST_ROOT);
+  }
+
+  virtual void TearDown() {
+    // Delete the unity test directory
+    bf::remove_all(TEST_ROOT);
+  }
+
+  bool WaitForOpen(nux::AsyncFileWriter& writer, unsigned timeout = 5) {
+    TestCallback opened;
+    TestCallback timed_out;
+    g_timeout_add_seconds(timeout, &TestCallback::glib_callback, &timed_out);
+    writer.opened.connect(opened.sigc_callback());
+
+    while (!opened.happened && !timed_out.happened) {
+      PumpGObjectMainLoop();
+    }
+    return opened.happened;
+  }
+
+  bool WaitForClose(nux::AsyncFileWriter& writer, unsigned timeout = 5) {
+    TestCallback closed;
+    TestCallback timed_out;
+    g_timeout_add_seconds(timeout, &TestCallback::glib_callback, &timed_out);
+    writer.closed.connect(closed.sigc_callback());
+
+    while (!closed.happened && !timed_out.happened) {
+      PumpGObjectMainLoop();
+    }
+    return closed.happened;
+  }
+
+};
+
+TEST_F(TestAsyncfileWriter, TestConstructor) {
+  std::string filename(TEST_ROOT + "/empty-file");
+  {
+    nux::AsyncFileWriter writer(filename);
+    bool opened = WaitForOpen(writer);
+    EXPECT_TRUE(opened);
+  }
+  EXPECT_TRUE(bf::exists(filename));
+  EXPECT_THAT(ReadFile(filename), Eq(""));
+}
+
+TEST_F(TestAsyncfileWriter, TestWrites) {
+  std::string filename(TEST_ROOT + "/write-file");
+  std::string data(200, 'x');
+  {
+    nux::AsyncFileWriter writer(filename);
+    writer.Write(data);
+    writer.Close();
+    bool closed = WaitForClose(writer);
+    EXPECT_TRUE(closed);
+  }
+  EXPECT_THAT(ReadFile(filename), Eq(data));
+}
+
+TEST_F(TestAsyncfileWriter, TestWriteLots) {
+  std::string filename(TEST_ROOT + "/lots-file");
+  std::string data(200, 'x');
+  const int loop_count = 1000;
+  {
+    nux::AsyncFileWriter writer(filename);
+    for (int i = 0; i < loop_count; ++i) {
+      writer.Write(data);
+    }
+    writer.Close();
+    bool closed = WaitForClose(writer);
+    EXPECT_TRUE(closed);
+  }
+  std::string file_content = ReadFile(filename);
+  EXPECT_THAT(file_content.size(), Eq(data.size() * loop_count));
+  // They are all x's.
+  EXPECT_THAT(file_content, MatchesRegex("^x+$"));
+}
+
+
+
+} // anon namespace

=== added file 'tests/test_main.cpp'
--- tests/test_main.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_main.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,10 @@
+#include <gtest/gtest.h>
+#include <glib-object.h>
+
+int main(int argc, char **argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  g_type_init();
+
+  return RUN_ALL_TESTS();
+}

=== added file 'tests/test_rolling_file_appender.cpp'
--- tests/test_rolling_file_appender.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_rolling_file_appender.cpp	2011-07-15 04:02:32 +0000
@@ -0,0 +1,147 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <fstream>
+#include <streambuf>
+#include <string>
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+#include "NuxCore/RollingFileAppender.h"
+#include "Helpers.h"
+
+namespace bf = boost::filesystem;
+
+using namespace nux::logging;
+using namespace nux::testing;
+using namespace testing;
+
+namespace {
+
+/**
+ * Due to the asynchronous manner in which the rolling file appender writes
+ * the data to disk, it is incredibly hard to test in a simple unit test as
+ * the underlying file on the file system isn't created synchronously, nor is
+ * the output written synchronously.
+ *
+ * A files_rolled event exists on the RollingFileAppender so we can at least
+ * wait for that signal and check the underlying files on the file system at
+ * that stage.  This does mean that we aren't testing the smaller chunks of
+ * how it works, but more only the complete system, which I guess has to be
+ * good enough for this case.
+ */
+
+const std::string TEST_ROOT("/tmp/nux-test-cases");
+
+class TestRollingFileAppender : public ::testing::Test
+{
+protected:
+  virtual void SetUp() {
+    // Make sure that the tests start with nothing there.
+    bf::remove_all(TEST_ROOT);
+  }
+
+  virtual void TearDown() {
+    // Delete the unity test directory
+    bf::remove_all(TEST_ROOT);
+  }
+
+  bool WaitForRoll(RollingFileAppender& appender, unsigned timeout = 5) {
+    TestCallback rolled;
+    TestCallback timed_out;
+    g_timeout_add_seconds(timeout, &TestCallback::glib_callback, &timed_out);
+    appender.files_rolled.connect(rolled.sigc_callback());
+
+    while (!rolled.happened && !timed_out.happened) {
+      PumpGObjectMainLoop();
+    }
+    return rolled.happened;
+  }
+
+};
+
+TEST_F(TestRollingFileAppender, NoTestRoot) {
+  // The test root should not exist.
+  EXPECT_FALSE(bf::exists(TEST_ROOT));
+}
+
+TEST_F(TestRollingFileAppender, TestLogFileRollsAtFlush) {
+
+  std::string logfile = TEST_ROOT + "/nux.log";
+  unsigned max_log_size = 20; // roll every 20 characters
+  RollingFileAppender output(logfile, 5, max_log_size);
+
+  output << "Testing the rolling of the logfile" << std::endl;
+  WaitForRoll(output);
+  output << "Long line greater than max_log_size" << std::endl;
+  WaitForRoll(output);
+
+  // Since the log files are rolled on flush, if the last thing written out
+  // takes the filesize greater than the max_log_size, the log files are
+  // rolled and the current file being appended to is now empty.
+  EXPECT_THAT(ReadFile(logfile + ".1"),
+              Eq("Long line greater than max_log_size\n"));
+  EXPECT_THAT(ReadFile(logfile + ".2"),
+              Eq("Testing the rolling of the logfile\n"));
+}
+
+TEST_F(TestRollingFileAppender, TestExistingLogFileMoved) {
+
+  std::string logfile = TEST_ROOT + "/nux.log";
+  {
+    bf::create_directories(bf::path(logfile).parent_path());
+    std::ofstream output(logfile);
+    output << "Existing file.";
+  }
+  EXPECT_TRUE(bf::exists(logfile));
+
+  RollingFileAppender output(logfile);
+
+  EXPECT_THAT(ReadFile(logfile + ".1"),
+              Eq("Existing file."));
+}
+
+TEST_F(TestRollingFileAppender, TestDeletingOld) {
+
+  std::string logfile = TEST_ROOT + "/nux.log";
+  // Two backups, size 20 bytes.
+  RollingFileAppender output(logfile, 2, 20);
+
+  // Due to the asynchronous manner in which the output is sent to the
+  // underlying file, we explicitly wait for the roll here.  Otherwise we may
+  // just send all the logging lines to one file then it would roll.
+  output << "Oldest line should be deleted." << std::endl;
+  WaitForRoll(output);
+  output << "This line will be in the last backup." << std::endl;
+  WaitForRoll(output);
+  output << "This is backup number 1." << std::endl;
+  WaitForRoll(output);
+
+  EXPECT_THAT(ReadFile(logfile + ".1"),
+              Eq("This is backup number 1.\n"));
+  EXPECT_THAT(ReadFile(logfile + ".2"),
+              Eq("This line will be in the last backup.\n"));
+  EXPECT_FALSE(bf::exists(logfile + ".3"));
+}
+
+TEST_F(TestRollingFileAppender, TestFullPathNeeded) {
+  EXPECT_THROW(RollingFileAppender("nux.log"), std::runtime_error);
+  EXPECT_THROW(RollingFileAppender("relative/nux.log"), std::runtime_error);
+}
+
+TEST_F(TestRollingFileAppender, TestFileNeeded) {
+  // For some obscure reason, EXPECT_THROW won't accept:
+  //  RollingFileAppender(logfile)
+  // as its first arg.
+  std::string directory_path = TEST_ROOT + "/somedir";
+  bf::create_directories(directory_path);
+  EXPECT_THROW(RollingFileAppender appender(directory_path), std::runtime_error);
+
+  std::string symlink_path = TEST_ROOT + "/somelink";
+  bf::create_symlink(directory_path, symlink_path);
+  EXPECT_THROW(RollingFileAppender appender(symlink_path), std::runtime_error);
+}
+
+
+} // anon namespace