4 # Copyright (C) 2009 Google Inc.
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful, but
12 # WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 """Asynchronous pyinotify implementation"""
29 # pylint: disable-msg=E0611
30 from pyinotify import pyinotify
34 from ganeti import daemon
35 from ganeti import errors
37 # We contributed the AsyncNotifier class back to python-pyinotify, and it's
38 # part of their codebase since version 0.8.7. This code can be removed once
39 # we'll be ready to depend on python-pyinotify >= 0.8.7
40 class AsyncNotifier(asyncore.file_dispatcher):
41 """An asyncore dispatcher for inotify events.
44 # pylint: disable-msg=W0622,W0212
45 def __init__(self, watch_manager, default_proc_fun=None, map=None):
46 """Initializes this class.
48 This is a a special asyncore file_dispatcher that actually wraps a
49 pyinotify Notifier, making it asyncronous.
52 if default_proc_fun is None:
53 default_proc_fun = pyinotify.ProcessEvent()
55 self.notifier = pyinotify.Notifier(watch_manager, default_proc_fun)
57 # here we need to steal the file descriptor from the notifier, so we can
58 # use it in the global asyncore select, and avoid calling the
59 # check_events() function of the notifier (which doesn't allow us to select
60 # together with other file descriptors)
61 self.fd = self.notifier._fd
62 asyncore.file_dispatcher.__init__(self, self.fd, map)
64 def handle_read(self):
65 self.notifier.read_events()
66 self.notifier.process_events()
69 class ErrorLoggingAsyncNotifier(AsyncNotifier,
70 daemon.GanetiBaseAsyncoreDispatcher):
71 """An asyncnotifier that can survive errors in the callbacks.
73 We define this as a separate class, since we don't want to make AsyncNotifier
74 diverge from what we contributed upstream.
79 class FileEventHandlerBase(pyinotify.ProcessEvent):
80 """Base class for file event handlers.
82 @ivar watch_manager: Inotify watch manager
85 def __init__(self, watch_manager):
86 """Initializes this class.
88 @type watch_manager: pyinotify.WatchManager
89 @param watch_manager: inotify watch manager
92 # pylint: disable-msg=W0231
93 # no need to call the parent's constructor
94 self.watch_manager = watch_manager
96 def process_default(self, event):
97 logging.error("Received unhandled inotify event: %s", event)
99 def AddWatch(self, filename, mask):
100 """Adds a file watch.
102 @param filename: Path to file
103 @param mask: Inotify event mask
107 result = self.watch_manager.add_watch(filename, mask)
109 ret = result.get(filename, -1)
111 raise errors.InotifyError("Could not add inotify watcher (%s)" % ret)
113 return result[filename]
115 def RemoveWatch(self, handle):
116 """Removes a handle from the watcher.
118 @param handle: Inotify handle
119 @return: Whether removal was successful
122 result = self.watch_manager.rm_watch(handle)
124 return result[handle]
127 class SingleFileEventHandler(FileEventHandlerBase):
128 """Handle modify events for a single file.
131 def __init__(self, watch_manager, callback, filename):
132 """Constructor for SingleFileEventHandler
134 @type watch_manager: pyinotify.WatchManager
135 @param watch_manager: inotify watch manager
136 @type callback: function accepting a boolean
137 @param callback: function to call when an inotify event happens
138 @type filename: string
139 @param filename: config file to watch
142 FileEventHandlerBase.__init__(self, watch_manager)
144 self._callback = callback
145 self._filename = filename
147 self._watch_handle = None
150 """Watch the given file.
153 if self._watch_handle is not None:
156 # Different Pyinotify versions have the flag constants at different places,
157 # hence not accessing them directly
158 mask = (pyinotify.EventsCodes.ALL_FLAGS["IN_MODIFY"] |
159 pyinotify.EventsCodes.ALL_FLAGS["IN_IGNORED"])
161 self._watch_handle = self.AddWatch(self._filename, mask)
164 """Stop watching the given file.
167 if self._watch_handle is not None and self.RemoveWatch(self._watch_handle):
168 self._watch_handle = None
170 # pylint: disable-msg=C0103
171 # this overrides a method in pyinotify.ProcessEvent
172 def process_IN_IGNORED(self, event):
173 # Since we monitor a single file rather than the directory it resides in,
174 # when that file is replaced with another one (which is what happens when
175 # utils.WriteFile, the most normal way of updating files in ganeti, is
176 # called) we're going to receive an IN_IGNORED event from inotify, because
177 # of the file removal (which is contextual with the replacement). In such a
178 # case we'll need to create a watcher for the "new" file. This can be done
179 # by the callback by calling "enable" again on us.
180 logging.debug("Received 'ignored' inotify event for %s", event.path)
181 self._watch_handle = None
182 self._callback(False)
184 # pylint: disable-msg=C0103
185 # this overrides a method in pyinotify.ProcessEvent
186 def process_IN_MODIFY(self, event):
187 # This gets called when the monitored file is modified. Note that this
188 # doesn't usually happen in Ganeti, as most of the time we're just
189 # replacing any file with a new one, at filesystem level, rather than
190 # actually changing it. (see utils.WriteFile)
191 logging.debug("Received 'modify' inotify event for %s", event.path)