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 (error code %s);" 
113                                  " increasing fs.inotify.max_user_watches sysctl" 
114                                  " might be necessary" % ret) 
115   
116      return result[filename] 
117   
118 -  def RemoveWatch(self, handle): 
119      """Removes a handle from the watcher. 
120   
121      @param handle: Inotify handle 
122      @return: Whether removal was successful 
123   
124      """ 
125      result = self.watch_manager.rm_watch(handle) 
126   
127      return result[handle] 
128   
129   
130 -class SingleFileEventHandler(FileEventHandlerBase): 
131    """Handle modify events for a single file. 
132   
133    """ 
134 -  def __init__(self, watch_manager, callback, filename): 
135      """Constructor for SingleFileEventHandler 
136   
137      @type watch_manager: pyinotify.WatchManager 
138      @param watch_manager: inotify watch manager 
139      @type callback: function accepting a boolean 
140      @param callback: function to call when an inotify event happens 
141      @type filename: string 
142      @param filename: config file to watch 
143   
144      """ 
145      FileEventHandlerBase.__init__(self, watch_manager) 
146   
147      self._callback = callback 
148      self._filename = filename 
149   
150      self._watch_handle = None 
151   
152 -  def enable(self): 
153      """Watch the given file. 
154   
155      """ 
156      if self._watch_handle is not None: 
157        return 
158   
159      # Different Pyinotify versions have the flag constants at different places, 
160      # hence not accessing them directly 
161      mask = (pyinotify.EventsCodes.ALL_FLAGS["IN_MODIFY"] | 
162              pyinotify.EventsCodes.ALL_FLAGS["IN_IGNORED"]) 
163   
164      self._watch_handle = self.AddWatch(self._filename, mask) 
165   
166 -  def disable(self): 
167      """Stop watching the given file. 
168   
169      """ 
170      if self._watch_handle is not None and self.RemoveWatch(self._watch_handle): 
171        self._watch_handle = None 
172   
173    # pylint: disable=C0103 
174    # this overrides a method in pyinotify.ProcessEvent 
175 -  def process_IN_IGNORED(self, event): 
176      # Since we monitor a single file rather than the directory it resides in, 
177      # when that file is replaced with another one (which is what happens when 
178      # utils.WriteFile, the most normal way of updating files in ganeti, is 
179      # called) we're going to receive an IN_IGNORED event from inotify, because 
180      # of the file removal (which is contextual with the replacement). In such a 
181      # case we'll need to create a watcher for the "new" file. This can be done 
182      # by the callback by calling "enable" again on us. 
183      logging.debug("Received 'ignored' inotify event for %s", event.path) 
184      self._watch_handle = None 
185      self._callback(False) 
186   
187    # pylint: disable=C0103 
188    # this overrides a method in pyinotify.ProcessEvent 
189 -  def process_IN_MODIFY(self, event): 
190      # This gets called when the monitored file is modified. Note that this 
191      # doesn't usually happen in Ganeti, as most of the time we're just 
192      # replacing any file with a new one, at filesystem level, rather than 
193      # actually changing it. (see utils.WriteFile) 
194      logging.debug("Received 'modify' inotify event for %s", event.path) 
195      self._callback(True) 
196