code.grnet.gr Git - ganeti-local/blob - lib/watcher/state.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 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 """Module keeping state for Ganeti watcher.
  23
  24 """
  25
  26 import os
  27 import time
  28 import logging
  29
  30 from ganeti import utils
  31 from ganeti import serializer
  32 from ganeti import errors
  33
  34
  35 # Delete any record that is older than 8 hours; this value is based on
  36 # the fact that the current retry counter is 5, and watcher runs every
  37 # 5 minutes, so it takes around half an hour to exceed the retry
  38 # counter, so 8 hours (16*1/2h) seems like a reasonable reset time
  39 RETRY_EXPIRATION = 8 * 3600
  40
  41 KEY_RESTART_COUNT = "restart_count"
  42 KEY_RESTART_WHEN = "restart_when"
  43 KEY_BOOT_ID = "bootid"
  44
  45
  46 def OpenStateFile(path):
  47   """Opens the state file and acquires a lock on it.
  48
  49   @type path: string
  50   @param path: Path to state file
  51
  52   """
  53   # The two-step dance below is necessary to allow both opening existing
  54   # file read/write and creating if not existing. Vanilla open will truncate
  55   # an existing file -or- allow creating if not existing.
  56   statefile_fd = os.open(path, os.O_RDWR | os.O_CREAT)
  57
  58   # Try to acquire lock on state file. If this fails, another watcher instance
  59   # might already be running or another program is temporarily blocking the
  60   # watcher from running.
  61   try:
  62     utils.LockFile(statefile_fd)
  63   except errors.LockError, err:
  64     logging.error("Can't acquire lock on state file %s: %s", path, err)
  65     return None
  66
  67   return os.fdopen(statefile_fd, "w+")
  68
  69
  70 class WatcherState(object):
  71   """Interface to a state file recording restart attempts.
  72
  73   """
  74   def __init__(self, statefile):
  75     """Open, lock, read and parse the file.
  76
  77     @type statefile: file
  78     @param statefile: State file object
  79
  80     """
  81     self.statefile = statefile
  82
  83     try:
  84       state_data = self.statefile.read()
  85       if not state_data:
  86         self._data = {}
  87       else:
  88         self._data = serializer.Load(state_data)
  89     except Exception, msg: # pylint: disable=W0703
  90       # Ignore errors while loading the file and treat it as empty
  91       self._data = {}
  92       logging.warning(("Invalid state file. Using defaults."
  93                        " Error message: %s"), msg)
  94
  95     if "instance" not in self._data:
  96       self._data["instance"] = {}
  97     if "node" not in self._data:
  98       self._data["node"] = {}
  99
 100     self._orig_data = serializer.Dump(self._data)
 101
 102   def Save(self, filename):
 103     """Save state to file, then unlock and close it.
 104
 105     """
 106     assert self.statefile
 107
 108     serialized_form = serializer.Dump(self._data)
 109     if self._orig_data == serialized_form:
 110       logging.debug("Data didn't change, just touching status file")
 111       os.utime(filename, None)
 112       return
 113
 114     # We need to make sure the file is locked before renaming it, otherwise
 115     # starting ganeti-watcher again at the same time will create a conflict.
 116     fd = utils.WriteFile(filename,
 117                          data=serialized_form,
 118                          prewrite=utils.LockFile, close=False)
 119     self.statefile = os.fdopen(fd, 'w+')
 120
 121   def Close(self):
 122     """Unlock configuration file and close it.
 123
 124     """
 125     assert self.statefile
 126
 127     # Files are automatically unlocked when closing them
 128     self.statefile.close()
 129     self.statefile = None
 130
 131   def GetNodeBootID(self, name):
 132     """Returns the last boot ID of a node or None.
 133
 134     """
 135     ndata = self._data["node"]
 136
 137     if name in ndata and KEY_BOOT_ID in ndata[name]:
 138       return ndata[name][KEY_BOOT_ID]
 139     return None
 140
 141   def SetNodeBootID(self, name, bootid):
 142     """Sets the boot ID of a node.
 143
 144     """
 145     assert bootid
 146
 147     ndata = self._data["node"]
 148
 149     ndata.setdefault(name, {})[KEY_BOOT_ID] = bootid
 150
 151   def NumberOfRestartAttempts(self, instance_name):
 152     """Returns number of previous restart attempts.
 153
 154     @type instance_name: string
 155     @param instance_name: the name of the instance to look up
 156
 157     """
 158     idata = self._data["instance"]
 159
 160     if instance_name in idata:
 161       return idata[instance_name][KEY_RESTART_COUNT]
 162
 163     return 0
 164
 165   def MaintainInstanceList(self, instances):
 166     """Perform maintenance on the recorded instances.
 167
 168     @type instances: list of string
 169     @param instances: the list of currently existing instances
 170
 171     """
 172     idict = self._data["instance"]
 173
 174     # First, delete obsolete instances
 175     obsolete_instances = set(idict).difference(instances)
 176     for inst in obsolete_instances:
 177       logging.debug("Forgetting obsolete instance %s", inst)
 178       idict.pop(inst, None)
 179
 180     # Second, delete expired records
 181     earliest = time.time() - RETRY_EXPIRATION
 182     expired_instances = [i for i in idict
 183                          if idict[i][KEY_RESTART_WHEN] < earliest]
 184     for inst in expired_instances:
 185       logging.debug("Expiring record for instance %s", inst)
 186       idict.pop(inst, None)
 187
 188   def RecordRestartAttempt(self, instance_name):
 189     """Record a restart attempt.
 190
 191     @type instance_name: string
 192     @param instance_name: the name of the instance being restarted
 193
 194     """
 195     idata = self._data["instance"]
 196
 197     inst = idata.setdefault(instance_name, {})
 198     inst[KEY_RESTART_WHEN] = time.time()
 199     inst[KEY_RESTART_COUNT] = inst.get(KEY_RESTART_COUNT, 0) + 1
 200
 201   def RemoveInstance(self, instance_name):
 202     """Update state to reflect that a machine is running.
 203
 204     This method removes the record for a named instance (as we only
 205     track down instances).
 206
 207     @type instance_name: string
 208     @param instance_name: the name of the instance to remove from books
 209
 210     """
 211     idata = self._data["instance"]
 212
 213     idata.pop(instance_name, None)