Head

GCC Code Coverage Report

Directory:	cvmfs/		Exec	Total	Coverage
File:	cvmfs/file_watcher.h	Lines:	4	4	100.0 %
Date:	2019-02-03 02:48:13	Branches:	0	0	- %


/**
 * This file is part of the CernVM File System.
 */

#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();

  /**
   * Handle function called per event
   *
   * @param file_path - the path of the file this event corresponds to
   * @param event - the type of event
   * @param clear_handler - (output) set this to true to have the event
   *                        handler remove from the loop after this call
   *
   * Should return false in case of failure.
   *
   * Setting the clear_handler parameter to false means that the FileWatcher
   * object will attempt to re-register the handler for the same file name
   * in the case a file was delete - useful for continuously watching a file
   * which may be deleted and recreated
   */
  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();

  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_


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/**
2			* This file is part of the CernVM File System.
3			*/
4
5			#ifndef CVMFS_FILE_WATCHER_H_
6			#define CVMFS_FILE_WATCHER_H_
7
8			#include <pthread.h>
9
10			#include <map>
11			#include <string>
12
13			namespace file_watcher {
14
15			enum Event {
16			kModified,
17			kRenamed,
18			kAttributes,
19			kHardlinked,
20			kDeleted,
21			kIgnored,
22			kInvalid
23			};
24
25			class EventHandler {
26			public:
27			EventHandler();
28			virtual ~EventHandler();
29
30			/**
31			* Handle function called per event
32			*
33			* @param file_path - the path of the file this event corresponds to
34			* @param event - the type of event
35			* @param clear_handler - (output) set this to true to have the event
36			* handler remove from the loop after this call
37			*
38			* Should return false in case of failure.
39			*
40			* Setting the clear_handler parameter to false means that the FileWatcher
41			* object will attempt to re-register the handler for the same file name
42			* in the case a file was delete - useful for continuously watching a file
43			* which may be deleted and recreated
44			*/
45			virtual bool Handle(const std::string& file_path,
46			Event event,
47			bool* clear_handler) = 0;
48			};
49
50		40	struct WatchRecord {
51		4	WatchRecord() : file_path_(), handler_(NULL) {}
52
53		4	WatchRecord(const std::string& path,
54			file_watcher::EventHandler* h)
55			: file_path_(path),
56		4	handler_(h) {}
57
58			std::string file_path_;
59			file_watcher::EventHandler* handler_;
60			};
61
62			class FileWatcher {
63			public:
64			typedef std::map<std::string, EventHandler*> HandlerMap;
65
66			FileWatcher();
67			virtual ~FileWatcher();
68
69			void RegisterHandler(const std::string& file_path,
70			EventHandler* handler);
71
72			bool Spawn();
73
74			void Stop();
75
76			protected:
77			// Delays controlling the backoff throttle when registering new watches
78			static const unsigned kInitialDelay;
79			static const unsigned kMaxDelay;
80			static const unsigned kResetDelay;
81
82			void RegisterFilter(const std::string& file_path,
83			EventHandler* handler);
84
85			virtual bool RunEventLoop(const HandlerMap& handler_map,
86			int read_pipe, int write_pipe) = 0;
87
88			virtual int TryRegisterFilter(const std::string& file_path) = 0;
89
90			std::map<int, WatchRecord> watch_records_;
91
92			private:
93			static void* BackgroundThread(void* d);
94
95			HandlerMap handler_map_;
96
97			int control_pipe_to_back_[2];
98			int control_pipe_to_front_[2];
99
100			pthread_t thread_;
101
102			bool started_;
103			};
104
105			} // namespace file_watcher
106
107			#endif // CVMFS_FILE_WATCHER_H_