Source Code for Module ganeti.asyncnotifier

  1  # 
  2  # 
  3   
  4  # Copyright (C) 2009 Google Inc. 
  5  # 
  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. 
 10  # 
 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. 
 15  # 
 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 
 19  # 02110-1301, USA. 
 20   
 21   
 22  """Asynchronous pyinotify implementation""" 
 23   
 24   
 25  import asyncore 
 26  import logging 
 27   
 28  try: 
 29    # pylint: disable-msg=E0611 
 30    from pyinotify import pyinotify 
 31  except ImportError: 
 32    import pyinotify 
 33   
 34  from ganeti import daemon 
 35  from ganeti import errors 
 36   
 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. 
 42   
 43    """ 
 44    # pylint: disable-msg=W0622,W0212 
 45 -  def __init__(self, watch_manager, default_proc_fun=None, map=None): 
 46      """Initializes this class. 
 47   
 48      This is a a special asyncore file_dispatcher that actually wraps a 
 49      pyinotify Notifier, making it asyncronous. 
 50   
 51      """ 
 52      if default_proc_fun is None: 
 53        default_proc_fun = pyinotify.ProcessEvent() 
 54   
 55      self.notifier = pyinotify.Notifier(watch_manager, default_proc_fun) 
 56   
 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) 
 63   
 64 -  def handle_read(self): 
 65      self.notifier.read_events() 
 66      self.notifier.process_events() 
 67   
 68   
 69 -class ErrorLoggingAsyncNotifier(AsyncNotifier, 
 70                                  daemon.GanetiBaseAsyncoreDispatcher): 
 71    """An asyncnotifier that can survive errors in the callbacks. 
 72   
 73    We define this as a separate class, since we don't want to make AsyncNotifier 
 74    diverge from what we contributed upstream. 
 75   
 76    """ 
 77   
 78   
 79 -class FileEventHandlerBase(pyinotify.ProcessEvent): 
 80    """Base class for file event handlers. 
 81   
 82    @ivar watch_manager: Inotify watch manager 
 83   
 84    """ 
 85 -  def __init__(self, watch_manager): 
 86      """Initializes this class. 
 87   
 88      @type watch_manager: pyinotify.WatchManager 
 89      @param watch_manager: inotify watch manager 
 90   
 91      """ 
 92      # pylint: disable-msg=W0231 
 93      # no need to call the parent's constructor 
 94      self.watch_manager = watch_manager 
 95   
 96 -  def process_default(self, event): 
 97      logging.error("Received unhandled inotify event: %s", event) 
 98   
 99 -  def AddWatch(self, filename, mask): 
100      """Adds a file watch. 
101   
102      @param filename: Path to file 
103      @param mask: Inotify event mask 
104      @return: Result 
105   
106      """ 
107      result = self.watch_manager.add_watch(filename, mask) 
108   
109      ret = result.get(filename, -1) 
110      if ret <= 0: 
111        raise errors.InotifyError("Could not add inotify watcher (%s)" % ret) 
112   
113      return result[filename] 
114   
115 -  def RemoveWatch(self, handle): 
116      """Removes a handle from the watcher. 
117   
118      @param handle: Inotify handle 
119      @return: Whether removal was successful 
120   
121      """ 
122      result = self.watch_manager.rm_watch(handle) 
123   
124      return result[handle] 
125   
126   
127 -class SingleFileEventHandler(FileEventHandlerBase): 
128    """Handle modify events for a single file. 
129   
130    """ 
131 -  def __init__(self, watch_manager, callback, filename): 
132      """Constructor for SingleFileEventHandler 
133   
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 
140   
141      """ 
142      FileEventHandlerBase.__init__(self, watch_manager) 
143   
144      self._callback = callback 
145      self._filename = filename 
146   
147      self._watch_handle = None 
148   
149 -  def enable(self): 
150      """Watch the given file. 
151   
152      """ 
153      if self._watch_handle is not None: 
154        return 
155   
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"]) 
160   
161      self._watch_handle = self.AddWatch(self._filename, mask) 
162   
163 -  def disable(self): 
164      """Stop watching the given file. 
165   
166      """ 
167      if self._watch_handle is not None and self.RemoveWatch(self._watch_handle): 
168        self._watch_handle = None 
169   
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) 
183   
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) 
192      self._callback(True) 
193