/home/mhx/git/github/libmoost/include/moost/io/file_watcher.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_IO_FILE_WATCHER_HPP__
#define MOOST_IO_FILE_WATCHER_HPP__

#include <map>
#include <string>
#include <limits>
#include <functional>

#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>

// for last_write_time and exists
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/exception.hpp>

#include "../thread/xtime_util.hpp"

namespace moost { namespace io {

class file_watcher
{
public:

  enum file_action
  {
    CREATED = 0, 
    CHANGED = 1, 
    DELETED = 2  
  };

  typedef boost::function<void(file_action action, const std::string & path)> callback_t;

private:

  std::map<std::string, callback_t > m_file_callback;

  std::map<std::string, std::pair<time_t, time_t> > m_file_modified;

  boost::mutex m_file_mutex;

  boost::shared_ptr< boost::thread> m_pthread;

  // m_run is thread-safe: it's mutex/conditioned to coordinate with the async watcher thread
  // when false, and the cond is signalled, the watcher thread will wake up and exit

  bool m_run;

  boost::mutex m_run_mutex;
  boost::condition m_run_cond;

  int m_sleep_ms;

  std::time_t last_write_time(const boost::filesystem::path & p)
  {
    try
    {
       if (!boost::filesystem::exists(p))
          return 0;
       return boost::filesystem::last_write_time(p);
    }
    catch (const boost::filesystem::filesystem_error &)
    {
       return 0; // we were very unlucky!
    }
    catch (const std::exception&)
    {
       return 0; // todo: handle differently
    }
  }

public:

  file_watcher(int sleep_ms = 500) :
    m_run(false), m_sleep_ms(sleep_ms)
  {
  }


  ~file_watcher()
  {
    stop();
  }


  void insert(const std::string & path,
              const callback_t & callback,
              bool call_now = false )
  {
    boost::mutex::scoped_lock lock(m_file_mutex);

    m_file_callback[path] = callback;

    boost::filesystem::path p(path);
    std::time_t lw = last_write_time(p);
    if (lw != 0)
    {
      m_file_modified[path] = std::make_pair(lw, lw);
      if ( call_now )
        callback(CHANGED, path);
    }
    else
    {
      m_file_modified.erase(path);
      if ( call_now )
        callback(DELETED, path);
    }
  }


  void erase(const std::string & path)
  {
    boost::mutex::scoped_lock lock(m_file_mutex);
    m_file_callback.erase(path);
    m_file_modified.erase(path);
  }


  void start()
  {
    boost::mutex::scoped_lock lock(m_run_mutex);
    if (m_run)
      return;
    m_run = true;
    m_pthread.reset(new boost::thread(boost::bind(&file_watcher::run, this)));
  }


  void stop()
  {
    {
      boost::mutex::scoped_lock lock(m_run_mutex);
      if (!m_run)
        return;
      m_run = false;
      // Notify the asynchronous monitor thread that it should wake up
      // if it's currently waiting on m_run_mutex
      m_run_cond.notify_one();
    }
    // can only join once we've released the mutex, so run() loop can finish up
    m_pthread->join();
  }

private:

  void run()
  {
    bool run = true;
    typedef std::pair< callback_t , std::pair< file_action, std::string> > notification;
    std::vector< notification> notifications;

    for (;;)
    {
      {
        // Lock and check m_run; if it was set to false, we must return ASAP
        boost::mutex::scoped_lock lock(m_run_mutex);
        run = m_run;
        if (!run)
          return;
        // We release the lock, block the thread until one second
        m_run_cond.timed_wait(lock, moost::thread::xtime_util::add_ms(moost::thread::xtime_util::now(), m_sleep_ms));
      }
      // If we are not running (e.g. when the destructor woke us up), return
      if (!run)
        return;

      // Clear the notifications vector where we will collect the events
      // that will be fired
      notifications.clear();
      {
        // Lock m_file_mutex while we are working on m_file_callback
        boost::mutex::scoped_lock lock(m_file_mutex);
        for (std::map<std::string, callback_t>::iterator it = m_file_callback.begin(); it != m_file_callback.end(); ++it)
        {
          boost::filesystem::path p(it->first);

          // Does the path exist?
          std::time_t lw = last_write_time(p);
          if (lw != 0)
          {
            // Check its last modification time and compare it with what we had earlier
            std::map< std::string, std::pair<time_t, time_t> >::iterator it_mod = m_file_modified.find(it->first);

            if (it_mod == m_file_modified.end())
            {
              // We haven't seen this file so far, so insert it into the
              // map and add a creation event that will be fired
              m_file_modified[it->first] = std::make_pair(lw, lw);
              notifications.push_back(std::make_pair(it->second, std::make_pair(CREATED, it->first)));
            }
            else
            {
              // only case we consider a real modification: prev prev mod != prev mod,
              // but this mod == prev mod
              // the idea is that we want to capture a write to a file,
              // but only notify when the write is finished

              if (lw == it_mod->second.second && it_mod->second.first != it_mod->second.second)
                notifications.push_back(std::make_pair(it->second, std::make_pair(CHANGED, it->first)));
              it_mod->second.first = it_mod->second.second;
              it_mod->second.second = lw;
            }
          }
          else
          {
            // The path does not exist. Did we have it before? If so, fire
            // a deletion event.
            std::map< std::string, std::pair<time_t, time_t> >::iterator it_mod = m_file_modified.find(it->first);
            if (it_mod != m_file_modified.end())
            {
              m_file_modified.erase(it_mod);
              notifications.push_back(std::make_pair(it->second, std::make_pair(DELETED, it->first)));
            }
          }
        }
      }

      // okay!  we've released our lock on m_file_callback and m_file_modified
      // so it's time to send off our notifications
      for (std::vector<notification>::iterator it = notifications.begin(); it != notifications.end(); ++it)
      {
        try
        {
          it->first(it->second.first, it->second.second);
        }
        catch (...)
        {
          // \todo  can we do better here than silently ignoring the exception?
        }
      }
    }
  }
};

}} // moost::io

#endif // MOOST_IO_FILE_WATCHER_HPP__