Statistics
| Branch: | Tag: | Revision:

root / lib / block / base.py @ 47e0abee

History | View | Annotate | Download (11 kB)

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
    """
123
    raise NotImplementedError
124

    
125
  def Remove(self):
126
    """Remove this device.
127

128
    This makes sense only for some of the device types: LV and file
129
    storage. Also note that if the device can't attach, the removal
130
    can't be completed.
131

132
    """
133
    raise NotImplementedError
134

    
135
  def Rename(self, new_id):
136
    """Rename this device.
137

138
    This may or may not make sense for a given device type.
139

140
    """
141
    raise NotImplementedError
142

    
143
  def Open(self, force=False):
144
    """Make the device ready for use.
145

146
    This makes the device ready for I/O. For now, just the DRBD
147
    devices need this.
148

149
    The force parameter signifies that if the device has any kind of
150
    --force thing, it should be used, we know what we are doing.
151

152
    @type force: boolean
153

154
    """
155
    raise NotImplementedError
156

    
157
  def Shutdown(self):
158
    """Shut down the device, freeing its children.
159

160
    This undoes the `Assemble()` work, except for the child
161
    assembling; as such, the children on the device are still
162
    assembled after this call.
163

164
    """
165
    raise NotImplementedError
166

    
167
  def SetSyncParams(self, params):
168
    """Adjust the synchronization parameters of the mirror.
169

170
    In case this is not a mirroring device, this is no-op.
171

172
    @param params: dictionary of LD level disk parameters related to the
173
    synchronization.
174
    @rtype: list
175
    @return: a list of error messages, emitted both by the current node and by
176
    children. An empty list means no errors.
177

178
    """
179
    result = []
180
    if self._children:
181
      for child in self._children:
182
        result.extend(child.SetSyncParams(params))
183
    return result
184

    
185
  def PauseResumeSync(self, pause):
186
    """Pause/Resume the sync of the mirror.
187

188
    In case this is not a mirroring device, this is no-op.
189

190
    @type pause: boolean
191
    @param pause: Whether to pause or resume
192

193
    """
194
    result = True
195
    if self._children:
196
      for child in self._children:
197
        result = result and child.PauseResumeSync(pause)
198
    return result
199

    
200
  def GetSyncStatus(self):
201
    """Returns the sync status of the device.
202

203
    If this device is a mirroring device, this function returns the
204
    status of the mirror.
205

206
    If sync_percent is None, it means the device is not syncing.
207

208
    If estimated_time is None, it means we can't estimate
209
    the time needed, otherwise it's the time left in seconds.
210

211
    If is_degraded is True, it means the device is missing
212
    redundancy. This is usually a sign that something went wrong in
213
    the device setup, if sync_percent is None.
214

215
    The ldisk parameter represents the degradation of the local
216
    data. This is only valid for some devices, the rest will always
217
    return False (not degraded).
218

219
    @rtype: objects.BlockDevStatus
220

221
    """
222
    return objects.BlockDevStatus(dev_path=self.dev_path,
223
                                  major=self.major,
224
                                  minor=self.minor,
225
                                  sync_percent=None,
226
                                  estimated_time=None,
227
                                  is_degraded=False,
228
                                  ldisk_status=constants.LDS_OKAY)
229

    
230
  def CombinedSyncStatus(self):
231
    """Calculate the mirror status recursively for our children.
232

233
    The return value is the same as for `GetSyncStatus()` except the
234
    minimum percent and maximum time are calculated across our
235
    children.
236

237
    @rtype: objects.BlockDevStatus
238

239
    """
240
    status = self.GetSyncStatus()
241

    
242
    min_percent = status.sync_percent
243
    max_time = status.estimated_time
244
    is_degraded = status.is_degraded
245
    ldisk_status = status.ldisk_status
246

    
247
    if self._children:
248
      for child in self._children:
249
        child_status = child.GetSyncStatus()
250

    
251
        if min_percent is None:
252
          min_percent = child_status.sync_percent
253
        elif child_status.sync_percent is not None:
254
          min_percent = min(min_percent, child_status.sync_percent)
255

    
256
        if max_time is None:
257
          max_time = child_status.estimated_time
258
        elif child_status.estimated_time is not None:
259
          max_time = max(max_time, child_status.estimated_time)
260

    
261
        is_degraded = is_degraded or child_status.is_degraded
262

    
263
        if ldisk_status is None:
264
          ldisk_status = child_status.ldisk_status
265
        elif child_status.ldisk_status is not None:
266
          ldisk_status = max(ldisk_status, child_status.ldisk_status)
267

    
268
    return objects.BlockDevStatus(dev_path=self.dev_path,
269
                                  major=self.major,
270
                                  minor=self.minor,
271
                                  sync_percent=min_percent,
272
                                  estimated_time=max_time,
273
                                  is_degraded=is_degraded,
274
                                  ldisk_status=ldisk_status)
275

    
276
  def SetInfo(self, text):
277
    """Update metadata with info text.
278

279
    Only supported for some device types.
280

281
    """
282
    for child in self._children:
283
      child.SetInfo(text)
284

    
285
  def Grow(self, amount, dryrun, backingstore):
286
    """Grow the block device.
287

288
    @type amount: integer
289
    @param amount: the amount (in mebibytes) to grow with
290
    @type dryrun: boolean
291
    @param dryrun: whether to execute the operation in simulation mode
292
        only, without actually increasing the size
293
    @param backingstore: whether to execute the operation on backing storage
294
        only, or on "logical" storage only; e.g. DRBD is logical storage,
295
        whereas LVM, file, RBD are backing storage
296

297
    """
298
    raise NotImplementedError
299

    
300
  def GetActualSize(self):
301
    """Return the actual disk size.
302

303
    @note: the device needs to be active when this is called
304

305
    """
306
    assert self.attached, "BlockDevice not attached in GetActualSize()"
307
    result = utils.RunCmd(["blockdev", "--getsize64", self.dev_path])
308
    if result.failed:
309
      ThrowError("blockdev failed (%s): %s",
310
                  result.fail_reason, result.output)
311
    try:
312
      sz = int(result.output.strip())
313
    except (ValueError, TypeError), err:
314
      ThrowError("Failed to parse blockdev output: %s", str(err))
315
    return sz
316

    
317
  def __repr__(self):
318
    return ("<%s: unique_id: %s, children: %s, %s:%s, %s>" %
319
            (self.__class__, self.unique_id, self._children,
320
             self.major, self.minor, self.dev_path))
321

    
322

    
323
def ThrowError(msg, *args):
324
  """Log an error to the node daemon and the raise an exception.
325

326
  @type msg: string
327
  @param msg: the text of the exception
328
  @raise errors.BlockDeviceError
329

330
  """
331
  if args:
332
    msg = msg % args
333
  logging.error(msg)
334
  raise errors.BlockDeviceError(msg)
335

    
336

    
337
def IgnoreError(fn, *args, **kwargs):
338
  """Executes the given function, ignoring BlockDeviceErrors.
339

340
  This is used in order to simplify the execution of cleanup or
341
  rollback functions.
342

343
  @rtype: boolean
344
  @return: True when fn didn't raise an exception, False otherwise
345

346
  """
347
  try:
348
    fn(*args, **kwargs)
349
    return True
350
  except errors.BlockDeviceError, err:
351
    logging.warning("Caught BlockDeviceError but ignoring: %s", str(err))
352
    return False