file_watcher.h

Go to the documentation of this file.

#ifndef CVMFS_FILE_WATCHER_H_
#define CVMFS_FILE_WATCHER_H_

#include <pthread.h>

#include <map>
#include <string>

namespace file_watcher {

enum Event {
  kModified,
  kRenamed,
  kAttributes,
  kHardlinked,
  kDeleted,
  kIgnored,
  kInvalid
};

class EventHandler {
 public:
  EventHandler();
  virtual ~EventHandler();

  virtual bool Handle(const std::string& file_path,
                      Event event,
                      bool* clear_handler) = 0;
};

struct WatchRecord {
  WatchRecord() : file_path_(), handler_(NULL) {}

  WatchRecord(const std::string& path,
              file_watcher::EventHandler* h)
      : file_path_(path),
        handler_(h) {}

  std::string file_path_;
  file_watcher::EventHandler* handler_;
};

class FileWatcher {
 public:
  typedef std::map<std::string, EventHandler*> HandlerMap;

  FileWatcher();
  virtual ~FileWatcher();
  static FileWatcher *Create();

  void RegisterHandler(const std::string& file_path,
                       EventHandler* handler);

  bool Spawn();

  void Stop();

 protected:
  // Delays controlling the backoff throttle when registering new watches
  static const unsigned kInitialDelay;
  static const unsigned kMaxDelay;
  static const unsigned kResetDelay;

  void RegisterFilter(const std::string& file_path,
                      EventHandler* handler);

  virtual bool RunEventLoop(const HandlerMap& handler_map,
                            int read_pipe, int write_pipe) = 0;

  virtual int TryRegisterFilter(const std::string& file_path) = 0;

  std::map<int, WatchRecord> watch_records_;

 private:
  static void* BackgroundThread(void* d);

  HandlerMap handler_map_;

  int control_pipe_to_back_[2];
  int control_pipe_to_front_[2];

  pthread_t thread_;

  bool started_;
};

}  // namespace file_watcher

#endif  // CVMFS_FILE_WATCHER_H_