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=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   
 38  # We contributed the AsyncNotifier class back to python-pyinotify, and it's 
 39  # part of their codebase since version 0.8.7. This code can be removed once 
 40  # we'll be ready to depend on python-pyinotify >= 0.8.7 
 41 -class AsyncNotifier(asyncore.file_dispatcher): 
 42    """An asyncore dispatcher for inotify events. 
 43   
 44    """ 
 45    # pylint: disable=W0622,W0212 
 46 -  def __init__(self, watch_manager, default_proc_fun=None, map=None): 
 47      """Initializes this class. 
 48   
 49      This is a a special asyncore file_dispatcher that actually wraps a 
 50      pyinotify Notifier, making it asyncronous. 
 51   
 52      """ 
 53      if default_proc_fun is None: 
 54        default_proc_fun = pyinotify.ProcessEvent() 
 55   
 56      self.notifier = pyinotify.Notifier(watch_manager, default_proc_fun) 
 57   
 58      # here we need to steal the file descriptor from the notifier, so we can 
 59      # use it in the global asyncore select, and avoid calling the 
 60      # check_events() function of the notifier (which doesn't allow us to select 
 61      # together with other file descriptors) 
 62      self.fd = self.notifier._fd 
 63      asyncore.file_dispatcher.__init__(self, self.fd, map) 
 64   
 65 -  def handle_read(self): 
 66      self.notifier.read_events() 
 67      self.notifier.process_events() 
 68   
 69   
 70 -class ErrorLoggingAsyncNotifier(AsyncNotifier, 
 71                                  daemon.GanetiBaseAsyncoreDispatcher): 
 72    """An asyncnotifier that can survive errors in the callbacks. 
 73   
 74    We define this as a separate class, since we don't want to make AsyncNotifier 
 75    diverge from what we contributed upstream. 
 76   
 77    """ 
 78   
 79   
 80 -class FileEventHandlerBase(pyinotify.ProcessEvent): 
 81    """Base class for file event handlers. 
 82   
 83    @ivar watch_manager: Inotify watch manager 
 84   
 85    """ 
 86 -  def __init__(self, watch_manager): 
 87      """Initializes this class. 
 88   
 89      @type watch_manager: pyinotify.WatchManager 
 90      @param watch_manager: inotify watch manager 
 91   
 92      """ 
 93      # pylint: disable=W0231 
 94      # no need to call the parent's constructor 
 95      self.watch_manager = watch_manager 
 96   
 97 -  def process_default(self, event): 
 98      logging.error("Received unhandled inotify event: %s", event) 
 99   
100 -  def AddWatch(self, filename, mask): 
101      """Adds a file watch. 
102   
103      @param filename: Path to file 
104      @param mask: Inotify event mask 
105      @return: Result 
106   
107      """ 
108      result = self.watch_manager.add_watch(filename, mask) 
109   
110      ret = result.get(filename, -1) 
111      if ret <= 0: 
112        raise errors.InotifyError("Could not add inotify watcher (%s)" % ret) 
113   
114      return result[filename] 
115   
116 -  def RemoveWatch(self, handle): 
117      """Removes a handle from the watcher. 
118   
119      @param handle: Inotify handle 
120      @return: Whether removal was successful 
121   
122      """ 
123      result = self.watch_manager.rm_watch(handle) 
124   
125      return result[handle] 
126   
127   
128 -class SingleFileEventHandler(FileEventHandlerBase): 
129    """Handle modify events for a single file. 
130   
131    """ 
132 -  def __init__(self, watch_manager, callback, filename): 
133      """Constructor for SingleFileEventHandler 
134   
135      @type watch_manager: pyinotify.WatchManager 
136      @param watch_manager: inotify watch manager 
137      @type callback: function accepting a boolean 
138      @param callback: function to call when an inotify event happens 
139      @type filename: string 
140      @param filename: config file to watch 
141   
142      """ 
143      FileEventHandlerBase.__init__(self, watch_manager) 
144   
145      self._callback = callback 
146      self._filename = filename 
147   
148      self._watch_handle = None 
149   
150 -  def enable(self): 
151      """Watch the given file. 
152   
153      """ 
154      if self._watch_handle is not None: 
155        return 
156   
157      # Different Pyinotify versions have the flag constants at different places, 
158      # hence not accessing them directly 
159      mask = (pyinotify.EventsCodes.ALL_FLAGS["IN_MODIFY"] | 
160              pyinotify.EventsCodes.ALL_FLAGS["IN_IGNORED"]) 
161   
162      self._watch_handle = self.AddWatch(self._filename, mask) 
163   
164 -  def disable(self): 
165      """Stop watching the given file. 
166   
167      """ 
168      if self._watch_handle is not None and self.RemoveWatch(self._watch_handle): 
169        self._watch_handle = None 
170   
171    # pylint: disable=C0103 
172    # this overrides a method in pyinotify.ProcessEvent 
173 -  def process_IN_IGNORED(self, event): 
174      # Since we monitor a single file rather than the directory it resides in, 
175      # when that file is replaced with another one (which is what happens when 
176      # utils.WriteFile, the most normal way of updating files in ganeti, is 
177      # called) we're going to receive an IN_IGNORED event from inotify, because 
178      # of the file removal (which is contextual with the replacement). In such a 
179      # case we'll need to create a watcher for the "new" file. This can be done 
180      # by the callback by calling "enable" again on us. 
181      logging.debug("Received 'ignored' inotify event for %s", event.path) 
182      self._watch_handle = None 
183      self._callback(False) 
184   
185    # pylint: disable=C0103 
186    # this overrides a method in pyinotify.ProcessEvent 
187 -  def process_IN_MODIFY(self, event): 
188      # This gets called when the monitored file is modified. Note that this 
189      # doesn't usually happen in Ganeti, as most of the time we're just 
190      # replacing any file with a new one, at filesystem level, rather than 
191      # actually changing it. (see utils.WriteFile) 
192      logging.debug("Received 'modify' inotify event for %s", event.path) 
193      self._callback(True) 
194