Source Code for Module ganeti.server.confd

  1  # 
  2  # 
  3   
  4  # Copyright (C) 2009, 2010 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  """Ganeti configuration daemon 
 23   
 24  Ganeti-confd is a daemon to query master candidates for configuration values. 
 25  It uses UDP+HMAC for authentication with a global cluster key. 
 26   
 27  """ 
 28   
 29  # pylint: disable-msg=C0103 
 30  # C0103: Invalid name ganeti-confd 
 31   
 32  import os 
 33  import sys 
 34  import logging 
 35  import time 
 36   
 37  try: 
 38    # pylint: disable-msg=E0611 
 39    from pyinotify import pyinotify 
 40  except ImportError: 
 41    import pyinotify 
 42   
 43  from optparse import OptionParser 
 44   
 45  from ganeti import asyncnotifier 
 46  from ganeti import confd 
 47  from ganeti.confd import server as confd_server 
 48  from ganeti import constants 
 49  from ganeti import errors 
 50  from ganeti import daemon 
 51  from ganeti import netutils 
 52   
 53   
 54 -class ConfdAsyncUDPServer(daemon.AsyncUDPSocket): 
 55    """The confd udp server, suitable for use with asyncore. 
 56   
 57    """ 
 58 -  def __init__(self, bind_address, port, processor): 
 59      """Constructor for ConfdAsyncUDPServer 
 60   
 61      @type bind_address: string 
 62      @param bind_address: socket bind address 
 63      @type port: int 
 64      @param port: udp port 
 65      @type processor: L{confd.server.ConfdProcessor} 
 66      @param processor: ConfdProcessor to use to handle queries 
 67   
 68      """ 
 69      family = netutils.IPAddress.GetAddressFamily(bind_address) 
 70      daemon.AsyncUDPSocket.__init__(self, family) 
 71      self.bind_address = bind_address 
 72      self.port = port 
 73      self.processor = processor 
 74      self.bind((bind_address, port)) 
 75      logging.debug("listening on ('%s':%d)", bind_address, port) 
 76   
 77    # this method is overriding a daemon.AsyncUDPSocket method 
 78 -  def handle_datagram(self, payload_in, ip, port): 
 79      try: 
 80        query = confd.UnpackMagic(payload_in) 
 81      except errors.ConfdMagicError, err: 
 82        logging.debug(err) 
 83        return 
 84   
 85      answer =  self.processor.ExecQuery(query, ip, port) 
 86      if answer is not None: 
 87        try: 
 88          self.enqueue_send(ip, port, confd.PackMagic(answer)) 
 89        except errors.UdpDataSizeError: 
 90          logging.error("Reply too big to fit in an udp packet.") 
 91   
 92   
 93 -class ConfdConfigurationReloader(object): 
 94    """Logic to control when to reload the ganeti configuration 
 95   
 96    This class is able to alter between inotify and polling, to rate-limit the 
 97    number of reloads. When using inotify it also supports a fallback timed 
 98    check, to verify that the reload hasn't failed. 
 99   
100    """ 
101 -  def __init__(self, processor, mainloop): 
102      """Constructor for ConfdConfigurationReloader 
103   
104      @type processor: L{confd.server.ConfdProcessor} 
105      @param processor: ganeti-confd ConfdProcessor 
106      @type mainloop: L{daemon.Mainloop} 
107      @param mainloop: ganeti-confd mainloop 
108   
109      """ 
110      self.processor = processor 
111      self.mainloop = mainloop 
112   
113      self.polling = True 
114      self.last_notification = 0 
115   
116      # Asyncronous inotify handler for config changes 
117      cfg_file = constants.CLUSTER_CONF_FILE 
118      self.wm = pyinotify.WatchManager() 
119      self.inotify_handler = asyncnotifier.SingleFileEventHandler(self.wm, 
120                                                                  self.OnInotify, 
121                                                                  cfg_file) 
122      notifier_class = asyncnotifier.ErrorLoggingAsyncNotifier 
123      self.notifier = notifier_class(self.wm, self.inotify_handler) 
124   
125      self.timer_handle = None 
126      self._EnableTimer() 
127   
128 -  def OnInotify(self, notifier_enabled): 
129      """Receive an inotify notification. 
130   
131      @type notifier_enabled: boolean 
132      @param notifier_enabled: whether the notifier is still enabled 
133   
134      """ 
135      current_time = time.time() 
136      time_delta = current_time - self.last_notification 
137      self.last_notification = current_time 
138   
139      if time_delta < constants.CONFD_CONFIG_RELOAD_RATELIMIT: 
140        logging.debug("Moving from inotify mode to polling mode") 
141        self.polling = True 
142        if notifier_enabled: 
143          self.inotify_handler.disable() 
144   
145      if not self.polling and not notifier_enabled: 
146        try: 
147          self.inotify_handler.enable() 
148        except errors.InotifyError: 
149          self.polling = True 
150   
151      try: 
152        reloaded = self.processor.reader.Reload() 
153        if reloaded: 
154          logging.info("Reloaded ganeti config") 
155        else: 
156          logging.debug("Skipped double config reload") 
157      except errors.ConfigurationError: 
158        self.DisableConfd() 
159        self.inotify_handler.disable() 
160        return 
161   
162      # Reset the timer. If we're polling it will go to the polling rate, if 
163      # we're not it will delay it again to its base safe timeout. 
164      self._ResetTimer() 
165   
166 -  def _DisableTimer(self): 
167      if self.timer_handle is not None: 
168        self.mainloop.scheduler.cancel(self.timer_handle) 
169        self.timer_handle = None 
170   
171 -  def _EnableTimer(self): 
172      if self.polling: 
173        timeout = constants.CONFD_CONFIG_RELOAD_RATELIMIT 
174      else: 
175        timeout = constants.CONFD_CONFIG_RELOAD_TIMEOUT 
176   
177      if self.timer_handle is None: 
178        self.timer_handle = self.mainloop.scheduler.enter( 
179          timeout, 1, self.OnTimer, []) 
180   
181 -  def _ResetTimer(self): 
182      self._DisableTimer() 
183      self._EnableTimer() 
184   
185 -  def OnTimer(self): 
186      """Function called when the timer fires 
187   
188      """ 
189      self.timer_handle = None 
190      reloaded = False 
191      was_disabled = False 
192      try: 
193        if self.processor.reader is None: 
194          was_disabled = True 
195          self.EnableConfd() 
196          reloaded = True 
197        else: 
198          reloaded = self.processor.reader.Reload() 
199      except errors.ConfigurationError: 
200        self.DisableConfd(silent=was_disabled) 
201        return 
202   
203      if self.polling and reloaded: 
204        logging.info("Reloaded ganeti config") 
205      elif reloaded: 
206        # We have reloaded the config files, but received no inotify event.  If 
207        # an event is pending though, we just happen to have timed out before 
208        # receiving it, so this is not a problem, and we shouldn't alert 
209        if not self.notifier.check_events() and not was_disabled: 
210          logging.warning("Config file reload at timeout (inotify failure)") 
211      elif self.polling: 
212        # We're polling, but we haven't reloaded the config: 
213        # Going back to inotify mode 
214        logging.debug("Moving from polling mode to inotify mode") 
215        self.polling = False 
216        try: 
217          self.inotify_handler.enable() 
218        except errors.InotifyError: 
219          self.polling = True 
220      else: 
221        logging.debug("Performed configuration check") 
222   
223      self._EnableTimer() 
224   
225 -  def DisableConfd(self, silent=False): 
226      """Puts confd in non-serving mode 
227   
228      """ 
229      if not silent: 
230        logging.warning("Confd is being disabled") 
231      self.processor.Disable() 
232      self.polling = False 
233      self._ResetTimer() 
234   
235 -  def EnableConfd(self): 
236      self.processor.Enable() 
237      logging.warning("Confd is being enabled") 
238      self.polling = True 
239      self._ResetTimer() 
240   
241   
242 -def CheckConfd(_, args): 
243    """Initial checks whether to run exit with a failure. 
244   
245    """ 
246    if args: # confd doesn't take any arguments 
247      print >> sys.stderr, ("Usage: %s [-f] [-d] [-b ADDRESS]" % sys.argv[0]) 
248      sys.exit(constants.EXIT_FAILURE) 
249   
250    # TODO: collapse HMAC daemons handling in daemons GenericMain, when we'll 
251    # have more than one. 
252    if not os.path.isfile(constants.CONFD_HMAC_KEY): 
253      print >> sys.stderr, "Need HMAC key %s to run" % constants.CONFD_HMAC_KEY 
254      sys.exit(constants.EXIT_FAILURE) 
255   
256    # TODO: once we have a cluster param specifying the address family 
257    # preference, we need to check if the requested options.bind_address does not 
258    # conflict with that. If so, we might warn or EXIT_FAILURE. 
259   
260   
261 -def PrepConfd(options, _): 
262    """Prep confd function, executed with PID file held 
263   
264    """ 
265    # TODO: clarify how the server and reloader variables work (they are 
266    # not used) 
267   
268    # pylint: disable-msg=W0612 
269    mainloop = daemon.Mainloop() 
270   
271    # Asyncronous confd UDP server 
272    processor = confd_server.ConfdProcessor() 
273    try: 
274      processor.Enable() 
275    except errors.ConfigurationError: 
276      # If enabling the processor has failed, we can still go on, but confd will 
277      # be disabled 
278      logging.warning("Confd is starting in disabled mode") 
279   
280    server = ConfdAsyncUDPServer(options.bind_address, options.port, processor) 
281   
282    # Configuration reloader 
283    reloader = ConfdConfigurationReloader(processor, mainloop) 
284   
285    return mainloop 
286   
287   
288 -def ExecConfd(options, args, prep_data): # pylint: disable-msg=W0613 
289    """Main confd function, executed with PID file held 
290   
291    """ 
292    mainloop = prep_data 
293    mainloop.Run() 
294   
295   
296 -def Main(): 
297    """Main function for the confd daemon. 
298   
299    """ 
300    parser = OptionParser(description="Ganeti configuration daemon", 
301                          usage="%prog [-f] [-d] [-b ADDRESS]", 
302                          version="%%prog (ganeti) %s" % 
303                          constants.RELEASE_VERSION) 
304   
305    daemon.GenericMain(constants.CONFD, parser, CheckConfd, PrepConfd, ExecConfd) 
306