this method is idempotent
"""
- return True
+ pass
def Attach(self):
"""Find a device which matches our config and attach to it.
"""
if not self.minor and not self.Attach():
# the LV does not exist
- return True
+ return
result = utils.RunCmd(["lvremove", "-f", "%s/%s" %
(self._vg_name, self._lv_name)])
if result.failed:
- logging.error("Can't lvremove: %s - %s",
- result.fail_reason, result.output)
-
- return not result.failed
+ _ThrowError("Can't lvremove: %s - %s", result.fail_reason, result.output)
def Rename(self, new_id):
"""Rename this logical volume.
"""
result = utils.RunCmd(["lvchange", "-ay", self.dev_path])
if result.failed:
- logging.error("Can't activate lv %s: %s", self.dev_path, result.output)
- return False
- return self.Attach()
+ _ThrowError("Can't activate lv %s: %s", self.dev_path, result.output)
def Shutdown(self):
"""Shutdown the device.
volumes on shutdown.
"""
- return True
+ pass
def GetSyncStatus(self):
"""Returns the sync status of the device.
# remove existing snapshot if found
snap = LogicalVolume((self._vg_name, snap_name), None)
- snap.Remove()
+ _IgnoreError(snap.Remove)
pvs_info = self.GetPVInfo(self._vg_name)
if not pvs_info:
"""
UNCONF_RE = re.compile(r"\s*[0-9]+:\s*cs:Unconfigured$")
- LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+st:([^/]+)/(\S+)"
+ LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+(?:st|ro):([^/]+)/(\S+)"
"\s+ds:([^/]+)/(\S+)\s+.*$")
SYNC_RE = re.compile(r"^.*\ssync'ed:\s*([0-9.]+)%.*"
"\sfinish: ([0-9]+):([0-9]+):([0-9]+)\s.*$")
"""Return data from /proc/drbd.
"""
- stat = open(filename, "r")
try:
- data = stat.read().splitlines()
- finally:
- stat.close()
+ stat = open(filename, "r")
+ try:
+ data = stat.read().splitlines()
+ finally:
+ stat.close()
+ except EnvironmentError, err:
+ if err.errno == errno.ENOENT:
+ _ThrowError("The file %s cannot be opened, check if the module"
+ " is loaded (%s)", filename, str(err))
+ else:
+ _ThrowError("Can't read the DRBD proc file %s: %s", filename, str(err))
if not data:
_ThrowError("Can't read any data from %s", filename)
return data
"""
result = utils.RunCmd(["blockdev", "--getsize", meta_device])
if result.failed:
- logging.error("Failed to get device size: %s - %s",
- result.fail_reason, result.output)
- return False
+ _ThrowError("Failed to get device size: %s - %s",
+ result.fail_reason, result.output)
try:
sectors = int(result.stdout)
except ValueError:
- logging.error("Invalid output from blockdev: '%s'", result.stdout)
- return False
+ _ThrowError("Invalid output from blockdev: '%s'", result.stdout)
bytes = sectors * 512
if bytes < 128 * 1024 * 1024: # less than 128MiB
- logging.error("Meta device too small (%.2fMib)", (bytes / 1024 / 1024))
- return False
+ _ThrowError("Meta device too small (%.2fMib)", (bytes / 1024 / 1024))
if bytes > (128 + 32) * 1024 * 1024: # account for an extra (big) PE on LVM
- logging.error("Meta device too big (%.2fMiB)", (bytes / 1024 / 1024))
- return False
- return True
+ _ThrowError("Meta device too big (%.2fMiB)", (bytes / 1024 / 1024))
def Rename(self, new_id):
"""Rename a device.
# value types
value = pyp.Word(pyp.alphanums + '_-/.:')
quoted = dbl_quote + pyp.CharsNotIn('"') + dbl_quote
- addr_port = (pyp.Word(pyp.nums + '.') + pyp.Literal(':').suppress() +
- number)
+ addr_type = (pyp.Optional(pyp.Literal("ipv4")).suppress() +
+ pyp.Optional(pyp.Literal("ipv6")).suppress())
+ addr_port = (addr_type + pyp.Word(pyp.nums + '.') +
+ pyp.Literal(':').suppress() + number)
# meta device, extended syntax
meta_value = ((value ^ quoted) + pyp.Literal('[').suppress() +
number + pyp.Word(']').suppress())
+ # device name, extended syntax
+ device_value = pyp.Literal("minor").suppress() + number
# a statement
stmt = (~rbrace + keyword + ~lbrace +
- pyp.Optional(addr_port ^ value ^ quoted ^ meta_value) +
+ pyp.Optional(addr_port ^ value ^ quoted ^ meta_value ^
+ device_value) +
pyp.Optional(defa) + semi +
pyp.Optional(pyp.restOfLine).suppress())
backend, meta, "0", "-e", "detach", "--create-device"]
result = utils.RunCmd(args)
if result.failed:
- logging.error("Can't attach local disk: %s", result.output)
- return not result.failed
+ _ThrowError("drbd%d: can't attach local disk: %s", minor, result.output)
@classmethod
def _AssembleNet(cls, minor, net_info, protocol,
if None in net_info:
# we don't want network connection and actually want to make
# sure its shutdown
- return cls._ShutdownNet(minor)
+ cls._ShutdownNet(minor)
+ return
# Workaround for a race condition. When DRBD is doing its dance to
# establish a connection with its peer, it also sends the
args.extend(["-a", hmac, "-x", secret])
result = utils.RunCmd(args)
if result.failed:
- logging.error("Can't setup network for dbrd device: %s - %s",
- result.fail_reason, result.output)
- return False
+ _ThrowError("drbd%d: can't setup network: %s - %s",
+ minor, result.fail_reason, result.output)
timeout = time.time() + 10
ok = False
ok = True
break
if not ok:
- logging.error("Timeout while configuring network")
- return False
- return True
+ _ThrowError("drbd%d: timeout while configuring network", minor)
def AddChildren(self, devices):
"""Add a disk to the DRBD device.
_ThrowError("drbd%d: children not ready during AddChildren", self.minor)
backend.Open()
meta.Open()
- if not self._CheckMetaSize(meta.dev_path):
- raise errors.BlockDeviceError("Invalid meta device size")
+ self._CheckMetaSize(meta.dev_path)
self._InitMeta(self._FindUnusedMinor(), meta.dev_path)
- if not self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path):
- raise errors.BlockDeviceError("Can't attach to local storage")
+ self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path)
self._children = devices
def RemoveChildren(self, devices):
_ThrowError("drbd%d: mismatch in local storage (%s != %s) in"
" RemoveChildren", self.minor, dev, child.dev_path)
- if not self._ShutdownLocal(self.minor):
- raise errors.BlockDeviceError("Can't detach from local storage")
+ self._ShutdownLocal(self.minor)
self._children = []
@classmethod
_ThrowError("drbd%d: DRBD disk missing network info in"
" DisconnectNet()", self.minor)
- ever_disconnected = self._ShutdownNet(self.minor)
+ ever_disconnected = _IgnoreError(self._ShutdownNet, self.minor)
timeout_limit = time.time() + self._NET_RECONFIG_TIMEOUT
sleep_time = 0.100 # we start the retry time at 100 miliseconds
while time.time() < timeout_limit:
# retry the disconnect, it seems possible that due to a
# well-time disconnect on the peer, my disconnect command might
# be ingored and forgotten
- ever_disconnected = self._ShutdownNet(self.minor) or ever_disconnected
+ ever_disconnected = _IgnoreError(self._ShutdownNet, self.minor) or \
+ ever_disconnected
time.sleep(sleep_time)
sleep_time = min(2, sleep_time * 1.5)
if not status.is_standalone:
_ThrowError("drbd%d: device is not standalone in AttachNet", self.minor)
- return self._AssembleNet(self.minor,
- (self._lhost, self._lport,
- self._rhost, self._rport),
- "C", dual_pri=multimaster)
+ self._AssembleNet(self.minor,
+ (self._lhost, self._lport, self._rhost, self._rport),
+ constants.DRBD_NET_PROTOCOL, dual_pri=multimaster,
+ hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
def Attach(self):
"""Check if our minor is configured.
- if not, we create it from zero
"""
- result = super(DRBD8, self).Assemble()
- if not result:
- return result
+ super(DRBD8, self).Assemble()
self.Attach()
if self.minor is None:
# local device completely unconfigured
- return self._FastAssemble()
+ self._FastAssemble()
else:
# we have to recheck the local and network status and try to fix
# the device
- return self._SlowAssemble()
+ self._SlowAssemble()
def _SlowAssemble(self):
"""Assembles the DRBD device from a (partially) configured device.
the attach if can return success.
"""
+ net_data = (self._lhost, self._lport, self._rhost, self._rport)
for minor in (self._aminor,):
info = self._GetDevInfo(self._GetShowData(minor))
match_l = self._MatchesLocal(info)
match_r = self._MatchesNet(info)
+
if match_l and match_r:
+ # everything matches
break
+
if match_l and not match_r and "local_addr" not in info:
- res_r = self._AssembleNet(minor,
- (self._lhost, self._lport,
- self._rhost, self._rport),
- constants.DRBD_NET_PROTOCOL,
- hmac=constants.DRBD_HMAC_ALG,
- secret=self._secret
- )
- if res_r:
- if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
- break
- # the weakest case: we find something that is only net attached
- # even though we were passed some children at init time
+ # disk matches, but not attached to network, attach and recheck
+ self._AssembleNet(minor, net_data, constants.DRBD_NET_PROTOCOL,
+ hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
+ if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
+ break
+ else:
+ _ThrowError("drbd%d: network attach successful, but 'drbdsetup"
+ " show' disagrees", minor)
+
if match_r and "local_dev" not in info:
- break
+ # no local disk, but network attached and it matches
+ self._AssembleLocal(minor, self._children[0].dev_path,
+ self._children[1].dev_path)
+ if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
+ break
+ else:
+ _ThrowError("drbd%d: disk attach successful, but 'drbdsetup"
+ " show' disagrees", minor)
# this case must be considered only if we actually have local
# storage, i.e. not in diskless mode, because all diskless
# else, even though its local storage is ours; as we own the
# drbd space, we try to disconnect from the remote peer and
# reconnect to our correct one
- if not self._ShutdownNet(minor):
- raise errors.BlockDeviceError("Device has correct local storage,"
- " wrong remote peer and is unable to"
- " disconnect in order to attach to"
- " the correct peer")
+ try:
+ self._ShutdownNet(minor)
+ except errors.BlockDeviceError, err:
+ _ThrowError("drbd%d: device has correct local storage, wrong"
+ " remote peer and is unable to disconnect in order"
+ " to attach to the correct peer: %s", minor, str(err))
# note: _AssembleNet also handles the case when we don't want
# local storage (i.e. one or more of the _[lr](host|port) is
# None)
- if (self._AssembleNet(minor, (self._lhost, self._lport,
- self._rhost, self._rport),
- constants.DRBD_NET_PROTOCOL,
- hmac=constants.DRBD_HMAC_ALG,
- secret=self._secret) and
- self._MatchesNet(self._GetDevInfo(self._GetShowData(minor)))):
+ self._AssembleNet(minor, net_data, constants.DRBD_NET_PROTOCOL,
+ hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
+ if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
break
+ else:
+ _ThrowError("drbd%d: network attach successful, but 'drbdsetup"
+ " show' disagrees", minor)
else:
minor = None
self._SetFromMinor(minor)
- return minor is not None
+ if minor is None:
+ _ThrowError("drbd%d: cannot activate, unknown or unhandled reason",
+ self._aminor)
def _FastAssemble(self):
"""Assemble the drbd device from zero.
This is run when in Assemble we detect our minor is unused.
"""
- # TODO: maybe completely tear-down the minor (drbdsetup ... down)
- # before attaching our own?
minor = self._aminor
- need_localdev_teardown = False
if self._children and self._children[0] and self._children[1]:
- result = self._AssembleLocal(minor, self._children[0].dev_path,
- self._children[1].dev_path)
- if not result:
- return False
- need_localdev_teardown = True
+ self._AssembleLocal(minor, self._children[0].dev_path,
+ self._children[1].dev_path)
if self._lhost and self._lport and self._rhost and self._rport:
- result = self._AssembleNet(minor,
- (self._lhost, self._lport,
- self._rhost, self._rport),
- constants.DRBD_NET_PROTOCOL,
- hmac=constants.DRBD_HMAC_ALG,
- secret=self._secret)
- if not result:
- if need_localdev_teardown:
- # we will ignore failures from this
- logging.error("net setup failed, tearing down local device")
- self._ShutdownAll(minor)
- return False
+ self._AssembleNet(minor,
+ (self._lhost, self._lport, self._rhost, self._rport),
+ constants.DRBD_NET_PROTOCOL,
+ hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
self._SetFromMinor(minor)
- return True
@classmethod
def _ShutdownLocal(cls, minor):
"""
result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])
if result.failed:
- logging.error("Can't detach local device: %s", result.output)
- return not result.failed
+ _ThrowError("drbd%d: can't detach local disk: %s", minor, result.output)
@classmethod
def _ShutdownNet(cls, minor):
"""
result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])
if result.failed:
- logging.error("Can't shutdown network: %s", result.output)
- return not result.failed
+ _ThrowError("drbd%d: can't shutdown network: %s", minor, result.output)
@classmethod
def _ShutdownAll(cls, minor):
"""
result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "down"])
if result.failed:
- logging.error("Can't shutdown drbd device: %s", result.output)
- return not result.failed
+ _ThrowError("drbd%d: can't shutdown drbd device: %s",
+ minor, result.output)
def Shutdown(self):
"""Shutdown the DRBD device.
"""
if self.minor is None and not self.Attach():
- logging.info("DRBD device not attached to a device during Shutdown")
- return True
- if not self._ShutdownAll(self.minor):
- return False
+ logging.info("drbd%d: not attached during Shutdown()", self._aminor)
+ return
+ minor = self.minor
self.minor = None
self.dev_path = None
- return True
+ self._ShutdownAll(minor)
def Remove(self):
"""Stub remove for DRBD devices.
"""
- return self.Shutdown()
+ self.Shutdown()
@classmethod
def Create(cls, unique_id, children, size):
else:
in_use = False
if in_use:
- _ThrowError("DRBD minor %d already in use at Create() time", aminor)
+ _ThrowError("drbd%d: minor is already in use at Create() time", aminor)
meta = children[1]
meta.Assemble()
if not meta.Attach():
- raise errors.BlockDeviceError("Can't attach to meta device")
- if not cls._CheckMetaSize(meta.dev_path):
- raise errors.BlockDeviceError("Invalid meta device size")
+ _ThrowError("drbd%d: can't attach to meta device '%s'",
+ aminor, meta)
+ cls._CheckMetaSize(meta.dev_path)
cls._InitMeta(aminor, meta.dev_path)
return cls(unique_id, children)
"""
if not os.path.exists(self.dev_path):
- raise errors.BlockDeviceError("File device '%s' does not exist." %
- self.dev_path)
- return True
+ _ThrowError("File device '%s' does not exist" % self.dev_path)
def Shutdown(self):
"""Shutdown the device.
the file on shutdown.
"""
- return True
+ pass
def Open(self, force=False):
"""Make the device ready for I/O.
@return: True if the removal was successful
"""
- if not os.path.exists(self.dev_path):
- return True
try:
os.remove(self.dev_path)
- return True
except OSError, err:
- logging.error("Can't remove file '%s': %s", self.dev_path, err)
- return False
+ if err.errno != errno.ENOENT:
+ _ThrowError("Can't remove file '%s': %s", self.dev_path, err)
def Attach(self):
"""Attach to an existing file.
@return: an instance of FileStorage
"""
- # TODO: decide whether we should check for existing files and
- # abort or not
if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
raise ValueError("Invalid configuration data %s" % str(unique_id))
dev_path = unique_id[1]
+ if os.path.exists(dev_path):
+ _ThrowError("File already existing: %s", dev_path)
try:
f = open(dev_path, 'w')
f.truncate(size * 1024 * 1024)
if dev_type not in DEV_MAP:
raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
device = DEV_MAP[dev_type](unique_id, children)
- if not device.Assemble():
- raise errors.BlockDeviceError("Can't find a valid block device for"
- " %s/%s/%s" %
- (dev_type, unique_id, children))
+ device.Assemble()
return device
projects / ganeti-local / blobdiff