code.grnet.gr Git - ganeti-local/blob - lib/storage/base.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2010, 2011, 2012, 2013 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 """Block device abstraction - base class and utility functions"""
  23
  24 import logging
  25
  26 from ganeti import objects
  27 from ganeti import constants
  28 from ganeti import utils
  29 from ganeti import errors
  30
  31
  32 class BlockDev(object):
  33   """Block device abstract class.
  34
  35   A block device can be in the following states:
  36     - not existing on the system, and by `Create()` it goes into:
  37     - existing but not setup/not active, and by `Assemble()` goes into:
  38     - active read-write and by `Open()` it goes into
  39     - online (=used, or ready for use)
  40
  41   A device can also be online but read-only, however we are not using
  42   the readonly state (LV has it, if needed in the future) and we are
  43   usually looking at this like at a stack, so it's easier to
  44   conceptualise the transition from not-existing to online and back
  45   like a linear one.
  46
  47   The many different states of the device are due to the fact that we
  48   need to cover many device types:
  49     - logical volumes are created, lvchange -a y $lv, and used
  50     - drbd devices are attached to a local disk/remote peer and made primary
  51
  52   A block device is identified by three items:
  53     - the /dev path of the device (dynamic)
  54     - a unique ID of the device (static)
  55     - it's major/minor pair (dynamic)
  56
  57   Not all devices implement both the first two as distinct items. LVM
  58   logical volumes have their unique ID (the pair volume group, logical
  59   volume name) in a 1-to-1 relation to the dev path. For DRBD devices,
  60   the /dev path is again dynamic and the unique id is the pair (host1,
  61   dev1), (host2, dev2).
  62
  63   You can get to a device in two ways:
  64     - creating the (real) device, which returns you
  65       an attached instance (lvcreate)
  66     - attaching of a python instance to an existing (real) device
  67
  68   The second point, the attachment to a device, is different
  69   depending on whether the device is assembled or not. At init() time,
  70   we search for a device with the same unique_id as us. If found,
  71   good. It also means that the device is already assembled. If not,
  72   after assembly we'll have our correct major/minor.
  73
  74   """
  75   def __init__(self, unique_id, children, size, params):
  76     self._children = children
  77     self.dev_path = None
  78     self.unique_id = unique_id
  79     self.major = None
  80     self.minor = None
  81     self.attached = False
  82     self.size = size
  83     self.params = params
  84
  85   def Assemble(self):
  86     """Assemble the device from its components.
  87
  88     Implementations of this method by child classes must ensure that:
  89       - after the device has been assembled, it knows its major/minor
  90         numbers; this allows other devices (usually parents) to probe
  91         correctly for their children
  92       - calling this method on an existing, in-use device is safe
  93       - if the device is already configured (and in an OK state),
  94         this method is idempotent
  95
  96     """
  97     pass
  98
  99   def Attach(self):
 100     """Find a device which matches our config and attach to it.
 101
 102     """
 103     raise NotImplementedError
 104
 105   def Close(self):
 106     """Notifies that the device will no longer be used for I/O.
 107
 108     """
 109     raise NotImplementedError
 110
 111   @classmethod
 112   def Create(cls, unique_id, children, size, params, excl_stor):
 113     """Create the device.
 114
 115     If the device cannot be created, it will return None
 116     instead. Error messages go to the logging system.
 117
 118     Note that for some devices, the unique_id is used, and for other,
 119     the children. The idea is that these two, taken together, are
 120     enough for both creation and assembly (later).
 121
 122     @type unique_id: 2-element tuple or list
 123     @param unique_id: unique identifier; the details depend on the actual device
 124         type
 125     @type children: list of L{BlockDev}
 126     @param children: for hierarchical devices, the child devices
 127     @type size: float
 128     @param size: size in MiB
 129     @type params: dict
 130     @param params: device-specific options/parameters
 131     @type excl_stor: bool
 132     @param excl_stor: whether exclusive_storage is active
 133     @rtype: L{BlockDev}
 134     @return: the created device, or C{None} in case of an error
 135
 136     """
 137     raise NotImplementedError
 138
 139   def Remove(self):
 140     """Remove this device.
 141
 142     This makes sense only for some of the device types: LV and file
 143     storage. Also note that if the device can't attach, the removal
 144     can't be completed.
 145
 146     """
 147     raise NotImplementedError
 148
 149   def Rename(self, new_id):
 150     """Rename this device.
 151
 152     This may or may not make sense for a given device type.
 153
 154     """
 155     raise NotImplementedError
 156
 157   def Open(self, force=False):
 158     """Make the device ready for use.
 159
 160     This makes the device ready for I/O. For now, just the DRBD
 161     devices need this.
 162
 163     The force parameter signifies that if the device has any kind of
 164     --force thing, it should be used, we know what we are doing.
 165
 166     @type force: boolean
 167
 168     """
 169     raise NotImplementedError
 170
 171   def Shutdown(self):
 172     """Shut down the device, freeing its children.
 173
 174     This undoes the `Assemble()` work, except for the child
 175     assembling; as such, the children on the device are still
 176     assembled after this call.
 177
 178     """
 179     raise NotImplementedError
 180
 181   def SetSyncParams(self, params):
 182     """Adjust the synchronization parameters of the mirror.
 183
 184     In case this is not a mirroring device, this is no-op.
 185
 186     @param params: dictionary of LD level disk parameters related to the
 187     synchronization.
 188     @rtype: list
 189     @return: a list of error messages, emitted both by the current node and by
 190     children. An empty list means no errors.
 191
 192     """
 193     result = []
 194     if self._children:
 195       for child in self._children:
 196         result.extend(child.SetSyncParams(params))
 197     return result
 198
 199   def PauseResumeSync(self, pause):
 200     """Pause/Resume the sync of the mirror.
 201
 202     In case this is not a mirroring device, this is no-op.
 203
 204     @type pause: boolean
 205     @param pause: Whether to pause or resume
 206
 207     """
 208     result = True
 209     if self._children:
 210       for child in self._children:
 211         result = result and child.PauseResumeSync(pause)
 212     return result
 213
 214   def GetSyncStatus(self):
 215     """Returns the sync status of the device.
 216
 217     If this device is a mirroring device, this function returns the
 218     status of the mirror.
 219
 220     If sync_percent is None, it means the device is not syncing.
 221
 222     If estimated_time is None, it means we can't estimate
 223     the time needed, otherwise it's the time left in seconds.
 224
 225     If is_degraded is True, it means the device is missing
 226     redundancy. This is usually a sign that something went wrong in
 227     the device setup, if sync_percent is None.
 228
 229     The ldisk parameter represents the degradation of the local
 230     data. This is only valid for some devices, the rest will always
 231     return False (not degraded).
 232
 233     @rtype: objects.BlockDevStatus
 234
 235     """
 236     return objects.BlockDevStatus(dev_path=self.dev_path,
 237                                   major=self.major,
 238                                   minor=self.minor,
 239                                   sync_percent=None,
 240                                   estimated_time=None,
 241                                   is_degraded=False,
 242                                   ldisk_status=constants.LDS_OKAY)
 243
 244   def CombinedSyncStatus(self):
 245     """Calculate the mirror status recursively for our children.
 246
 247     The return value is the same as for `GetSyncStatus()` except the
 248     minimum percent and maximum time are calculated across our
 249     children.
 250
 251     @rtype: objects.BlockDevStatus
 252
 253     """
 254     status = self.GetSyncStatus()
 255
 256     min_percent = status.sync_percent
 257     max_time = status.estimated_time
 258     is_degraded = status.is_degraded
 259     ldisk_status = status.ldisk_status
 260
 261     if self._children:
 262       for child in self._children:
 263         child_status = child.GetSyncStatus()
 264
 265         if min_percent is None:
 266           min_percent = child_status.sync_percent
 267         elif child_status.sync_percent is not None:
 268           min_percent = min(min_percent, child_status.sync_percent)
 269
 270         if max_time is None:
 271           max_time = child_status.estimated_time
 272         elif child_status.estimated_time is not None:
 273           max_time = max(max_time, child_status.estimated_time)
 274
 275         is_degraded = is_degraded or child_status.is_degraded
 276
 277         if ldisk_status is None:
 278           ldisk_status = child_status.ldisk_status
 279         elif child_status.ldisk_status is not None:
 280           ldisk_status = max(ldisk_status, child_status.ldisk_status)
 281
 282     return objects.BlockDevStatus(dev_path=self.dev_path,
 283                                   major=self.major,
 284                                   minor=self.minor,
 285                                   sync_percent=min_percent,
 286                                   estimated_time=max_time,
 287                                   is_degraded=is_degraded,
 288                                   ldisk_status=ldisk_status)
 289
 290   def SetInfo(self, text):
 291     """Update metadata with info text.
 292
 293     Only supported for some device types.
 294
 295     """
 296     for child in self._children:
 297       child.SetInfo(text)
 298
 299   def Grow(self, amount, dryrun, backingstore):
 300     """Grow the block device.
 301
 302     @type amount: integer
 303     @param amount: the amount (in mebibytes) to grow with
 304     @type dryrun: boolean
 305     @param dryrun: whether to execute the operation in simulation mode
 306         only, without actually increasing the size
 307     @param backingstore: whether to execute the operation on backing storage
 308         only, or on "logical" storage only; e.g. DRBD is logical storage,
 309         whereas LVM, file, RBD are backing storage
 310
 311     """
 312     raise NotImplementedError
 313
 314   def GetActualSize(self):
 315     """Return the actual disk size.
 316
 317     @note: the device needs to be active when this is called
 318
 319     """
 320     assert self.attached, "BlockDevice not attached in GetActualSize()"
 321     result = utils.RunCmd(["blockdev", "--getsize64", self.dev_path])
 322     if result.failed:
 323       ThrowError("blockdev failed (%s): %s",
 324                   result.fail_reason, result.output)
 325     try:
 326       sz = int(result.output.strip())
 327     except (ValueError, TypeError), err:
 328       ThrowError("Failed to parse blockdev output: %s", str(err))
 329     return sz
 330
 331   def __repr__(self):
 332     return ("<%s: unique_id: %s, children: %s, %s:%s, %s>" %
 333             (self.__class__, self.unique_id, self._children,
 334              self.major, self.minor, self.dev_path))
 335
 336
 337 def ThrowError(msg, *args):
 338   """Log an error to the node daemon and the raise an exception.
 339
 340   @type msg: string
 341   @param msg: the text of the exception
 342   @raise errors.BlockDeviceError
 343
 344   """
 345   if args:
 346     msg = msg % args
 347   logging.error(msg)
 348   raise errors.BlockDeviceError(msg)
 349
 350
 351 def IgnoreError(fn, *args, **kwargs):
 352   """Executes the given function, ignoring BlockDeviceErrors.
 353
 354   This is used in order to simplify the execution of cleanup or
 355   rollback functions.
 356
 357   @rtype: boolean
 358   @return: True when fn didn't raise an exception, False otherwise
 359
 360   """
 361   try:
 362     fn(*args, **kwargs)
 363     return True
 364   except errors.BlockDeviceError, err:
 365     logging.warning("Caught BlockDeviceError but ignoring: %s", str(err))
 366     return False