code.grnet.gr Git - ganeti-local/blob - lib/storage/drbd_cmdgen.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 """DRBD command generating classes"""
  23
  24 import logging
  25 import shlex
  26
  27 from ganeti import constants
  28 from ganeti import errors
  29
  30
  31 class BaseDRBDCmdGenerator(object):
  32   """Base class for DRBD command generators.
  33
  34   This class defines the interface for the command generators and holds shared
  35   code.
  36
  37   """
  38   def __init__(self, version):
  39     self._version = version
  40
  41   def GenShowCmd(self, minor):
  42     raise NotImplementedError
  43
  44   def GenInitMetaCmd(self, minor, meta_dev):
  45     raise NotImplementedError
  46
  47   def GenLocalInitCmds(self, minor, data_dev, meta_dev, size_mb, params):
  48     raise NotImplementedError
  49
  50   def GenNetInitCmd(self, minor, family, lhost, lport, rhost, rport, protocol,
  51                     dual_pri, hmac, secret, params):
  52     raise NotImplementedError
  53
  54   def GenSyncParamsCmd(self, minor, params):
  55     raise NotImplementedError
  56
  57   def GenPauseSyncCmd(self, minor):
  58     raise NotImplementedError
  59
  60   def GenResumeSyncCmd(self, minor):
  61     raise NotImplementedError
  62
  63   def GenPrimaryCmd(self, minor, force):
  64     raise NotImplementedError
  65
  66   def GenSecondaryCmd(self, minor):
  67     raise NotImplementedError
  68
  69   def GenDetachCmd(self, minor):
  70     raise NotImplementedError
  71
  72   def GenDisconnectCmd(self, minor, family, lhost, lport, rhost, rport):
  73     raise NotImplementedError
  74
  75   def GenDownCmd(self, minor):
  76     raise NotImplementedError
  77
  78   def GenResizeCmd(self, minor, size_mb):
  79     raise NotImplementedError
  80
  81   @staticmethod
  82   def _DevPath(minor):
  83     """Return the path to a drbd device for a given minor.
  84
  85     """
  86     return "/dev/drbd%d" % minor
  87
  88
  89 class DRBD83CmdGenerator(BaseDRBDCmdGenerator):
  90   """Generates drbdsetup commands suited for the DRBD <= 8.3 syntax.
  91
  92   """
  93   # command line options for barriers
  94   _DISABLE_DISK_OPTION = "--no-disk-barrier"  # -a
  95   _DISABLE_DRAIN_OPTION = "--no-disk-drain"   # -D
  96   _DISABLE_FLUSH_OPTION = "--no-disk-flushes" # -i
  97   _DISABLE_META_FLUSH_OPTION = "--no-md-flushes"  # -m
  98
  99   def __init__(self, version):
 100     super(DRBD83CmdGenerator, self).__init__(version)
 101
 102   def GenShowCmd(self, minor):
 103     return ["drbdsetup", self._DevPath(minor), "show"]
 104
 105   def GenInitMetaCmd(self, minor, meta_dev):
 106     return ["drbdmeta", "--force", self._DevPath(minor),
 107             "v08", meta_dev, "0", "create-md"]
 108
 109   def GenLocalInitCmds(self, minor, data_dev, meta_dev, size_mb, params):
 110     args = ["drbdsetup", self._DevPath(minor), "disk",
 111             data_dev, meta_dev, "0",
 112             "-e", "detach",
 113             "--create-device"]
 114     if size_mb:
 115       args.extend(["-d", "%sm" % size_mb])
 116
 117     vmaj = self._version["k_major"]
 118     vmin = self._version["k_minor"]
 119     vrel = self._version["k_point"]
 120
 121     barrier_args = \
 122       self._ComputeDiskBarrierArgs(vmaj, vmin, vrel,
 123                                    params[constants.LDP_BARRIERS],
 124                                    params[constants.LDP_NO_META_FLUSH])
 125     args.extend(barrier_args)
 126
 127     if params[constants.LDP_DISK_CUSTOM]:
 128       args.extend(shlex.split(params[constants.LDP_DISK_CUSTOM]))
 129
 130     return [args]
 131
 132   def GenNetInitCmd(self, minor, family, lhost, lport, rhost, rport, protocol,
 133                     dual_pri, hmac, secret, params):
 134     args = ["drbdsetup", self._DevPath(minor), "net",
 135             "%s:%s:%s" % (family, lhost, lport),
 136             "%s:%s:%s" % (family, rhost, rport), protocol,
 137             "-A", "discard-zero-changes",
 138             "-B", "consensus",
 139             "--create-device",
 140             ]
 141     if dual_pri:
 142       args.append("-m")
 143     if hmac and secret:
 144       args.extend(["-a", hmac, "-x", secret])
 145
 146     if params[constants.LDP_NET_CUSTOM]:
 147       args.extend(shlex.split(params[constants.LDP_NET_CUSTOM]))
 148
 149     return args
 150
 151   def GenSyncParamsCmd(self, minor, params):
 152     args = ["drbdsetup", self._DevPath(minor), "syncer"]
 153     if params[constants.LDP_DYNAMIC_RESYNC]:
 154       vmin = self._version["k_minor"]
 155       vrel = self._version["k_point"]
 156
 157       # By definition we are using 8.x, so just check the rest of the version
 158       # number
 159       if vmin != 3 or vrel < 9:
 160         msg = ("The current DRBD version (8.%d.%d) does not support the "
 161                "dynamic resync speed controller" % (vmin, vrel))
 162         logging.error(msg)
 163         return [msg]
 164
 165       if params[constants.LDP_PLAN_AHEAD] == 0:
 166         msg = ("A value of 0 for c-plan-ahead disables the dynamic sync speed"
 167                " controller at DRBD level. If you want to disable it, please"
 168                " set the dynamic-resync disk parameter to False.")
 169         logging.error(msg)
 170         return [msg]
 171
 172       # add the c-* parameters to args
 173       args.extend(["--c-plan-ahead", params[constants.LDP_PLAN_AHEAD],
 174                    "--c-fill-target", params[constants.LDP_FILL_TARGET],
 175                    "--c-delay-target", params[constants.LDP_DELAY_TARGET],
 176                    "--c-max-rate", params[constants.LDP_MAX_RATE],
 177                    "--c-min-rate", params[constants.LDP_MIN_RATE],
 178                    ])
 179
 180     else:
 181       args.extend(["-r", "%d" % params[constants.LDP_RESYNC_RATE]])
 182
 183     args.append("--create-device")
 184
 185     return args
 186
 187   def GenPauseSyncCmd(self, minor):
 188     return ["drbdsetup", self._DevPath(minor), "pause-sync"]
 189
 190   def GenResumeSyncCmd(self, minor):
 191     return ["drbdsetup", self._DevPath(minor), "resume-sync"]
 192
 193   def GenPrimaryCmd(self, minor, force):
 194     cmd = ["drbdsetup", self._DevPath(minor), "primary"]
 195
 196     if force:
 197       cmd.append("-o")
 198
 199     return cmd
 200
 201   def GenSecondaryCmd(self, minor):
 202     return ["drbdsetup", self._DevPath(minor), "secondary"]
 203
 204   def GenDetachCmd(self, minor):
 205     return ["drbdsetup", self._DevPath(minor), "detach"]
 206
 207   def GenDisconnectCmd(self, minor, family, lhost, lport, rhost, rport):
 208     return ["drbdsetup", self._DevPath(minor), "disconnect"]
 209
 210   def GenDownCmd(self, minor):
 211     return ["drbdsetup", self._DevPath(minor), "down"]
 212
 213   def GenResizeCmd(self, minor, size_mb):
 214     return ["drbdsetup", self._DevPath(minor), "resize", "-s", "%dm" % size_mb]
 215
 216   @classmethod
 217   def _ComputeDiskBarrierArgs(cls, vmaj, vmin, vrel, disabled_barriers,
 218                               disable_meta_flush):
 219     """Compute the DRBD command line parameters for disk barriers
 220
 221     Returns a list of the disk barrier parameters as requested via the
 222     disabled_barriers and disable_meta_flush arguments, and according to the
 223     supported ones in the DRBD version vmaj.vmin.vrel
 224
 225     If the desired option is unsupported, raises errors.BlockDeviceError.
 226
 227     """
 228     disabled_barriers_set = frozenset(disabled_barriers)
 229     if not disabled_barriers_set in constants.DRBD_VALID_BARRIER_OPT:
 230       raise errors.BlockDeviceError("%s is not a valid option set for DRBD"
 231                                     " barriers" % disabled_barriers)
 232
 233     args = []
 234
 235     # The following code assumes DRBD 8.x, with x < 4 and x != 1 (DRBD 8.1.x
 236     # does not exist)
 237     if not vmaj == 8 and vmin in (0, 2, 3):
 238       raise errors.BlockDeviceError("Unsupported DRBD version: %d.%d.%d" %
 239                                     (vmaj, vmin, vrel))
 240
 241     def _AppendOrRaise(option, min_version):
 242       """Helper for DRBD options"""
 243       if min_version is not None and vrel >= min_version:
 244         args.append(option)
 245       else:
 246         raise errors.BlockDeviceError("Could not use the option %s as the"
 247                                       " DRBD version %d.%d.%d does not support"
 248                                       " it." % (option, vmaj, vmin, vrel))
 249
 250     # the minimum version for each feature is encoded via pairs of (minor
 251     # version -> x) where x is version in which support for the option was
 252     # introduced.
 253     meta_flush_supported = disk_flush_supported = {
 254       0: 12,
 255       2: 7,
 256       3: 0,
 257       }
 258
 259     disk_drain_supported = {
 260       2: 7,
 261       3: 0,
 262       }
 263
 264     disk_barriers_supported = {
 265       3: 0,
 266       }
 267
 268     # meta flushes
 269     if disable_meta_flush:
 270       _AppendOrRaise(cls._DISABLE_META_FLUSH_OPTION,
 271                      meta_flush_supported.get(vmin, None))
 272
 273     # disk flushes
 274     if constants.DRBD_B_DISK_FLUSH in disabled_barriers_set:
 275       _AppendOrRaise(cls._DISABLE_FLUSH_OPTION,
 276                      disk_flush_supported.get(vmin, None))
 277
 278     # disk drain
 279     if constants.DRBD_B_DISK_DRAIN in disabled_barriers_set:
 280       _AppendOrRaise(cls._DISABLE_DRAIN_OPTION,
 281                      disk_drain_supported.get(vmin, None))
 282
 283     # disk barriers
 284     if constants.DRBD_B_DISK_BARRIERS in disabled_barriers_set:
 285       _AppendOrRaise(cls._DISABLE_DISK_OPTION,
 286                      disk_barriers_supported.get(vmin, None))
 287
 288     return args
 289
 290
 291 class DRBD84CmdGenerator(BaseDRBDCmdGenerator):
 292   """Generates drbdsetup commands suited for the DRBD >= 8.4 syntax.
 293
 294   """
 295   # command line options for barriers
 296   _DISABLE_DISK_OPTION = "--disk-barrier=no"
 297   _DISABLE_DRAIN_OPTION = "--disk-drain=no"
 298   _DISABLE_FLUSH_OPTION = "--disk-flushes=no"
 299   _DISABLE_META_FLUSH_OPTION = "--md-flushes=no"
 300
 301   def __init__(self, version):
 302     super(DRBD84CmdGenerator, self).__init__(version)
 303
 304   def GenShowCmd(self, minor):
 305     return ["drbdsetup", "show", minor]
 306
 307   def GenInitMetaCmd(self, minor, meta_dev):
 308     return ["drbdmeta", "--force", self._DevPath(minor),
 309             "v08", meta_dev, "flex-external", "create-md"]
 310
 311   def GenLocalInitCmds(self, minor, data_dev, meta_dev, size_mb, params):
 312     cmds = []
 313
 314     cmds.append(["drbdsetup", "new-resource", self._GetResource(minor)])
 315     cmds.append(["drbdsetup", "new-minor", self._GetResource(minor),
 316                  str(minor), "0"])
 317     # We need to apply the activity log before attaching the disk else drbdsetup
 318     # will fail.
 319     cmds.append(["drbdmeta", self._DevPath(minor),
 320                  "v08", meta_dev, "flex-external", "apply-al"])
 321
 322     attach_cmd = ["drbdsetup", "attach", minor, data_dev, meta_dev, "flexible",
 323                   "--on-io-error=detach"]
 324     if size_mb:
 325       attach_cmd.extend(["--size", "%sm" % size_mb])
 326
 327     barrier_args = \
 328       self._ComputeDiskBarrierArgs(params[constants.LDP_BARRIERS],
 329                                    params[constants.LDP_NO_META_FLUSH])
 330     attach_cmd.extend(barrier_args)
 331
 332     if params[constants.LDP_DISK_CUSTOM]:
 333       attach_cmd.extend(shlex.split(params[constants.LDP_DISK_CUSTOM]))
 334
 335     cmds.append(attach_cmd)
 336
 337     return cmds
 338
 339   def GenNetInitCmd(self, minor, family, lhost, lport, rhost, rport, protocol,
 340                     dual_pri, hmac, secret, params):
 341     args = ["drbdsetup", "connect", self._GetResource(minor),
 342             "%s:%s:%s" % (family, lhost, lport),
 343             "%s:%s:%s" % (family, rhost, rport),
 344             "--protocol", protocol,
 345             "--after-sb-0pri", "discard-zero-changes",
 346             "--after-sb-1pri", "consensus"
 347             ]
 348     if dual_pri:
 349       args.append("--allow-two-primaries")
 350     if hmac and secret:
 351       args.extend(["--cram-hmac-alg", hmac, "--shared-secret", secret])
 352
 353     if params[constants.LDP_NET_CUSTOM]:
 354       args.extend(shlex.split(params[constants.LDP_NET_CUSTOM]))
 355
 356     return args
 357
 358   def GenSyncParamsCmd(self, minor, params):
 359     args = ["drbdsetup", "disk-options", minor]
 360     if params[constants.LDP_DYNAMIC_RESYNC]:
 361       if params[constants.LDP_PLAN_AHEAD] == 0:
 362         msg = ("A value of 0 for c-plan-ahead disables the dynamic sync speed"
 363                " controller at DRBD level. If you want to disable it, please"
 364                " set the dynamic-resync disk parameter to False.")
 365         logging.error(msg)
 366         return [msg]
 367
 368       # add the c-* parameters to args
 369       args.extend(["--c-plan-ahead", params[constants.LDP_PLAN_AHEAD],
 370                    "--c-fill-target", params[constants.LDP_FILL_TARGET],
 371                    "--c-delay-target", params[constants.LDP_DELAY_TARGET],
 372                    "--c-max-rate", params[constants.LDP_MAX_RATE],
 373                    "--c-min-rate", params[constants.LDP_MIN_RATE],
 374                    ])
 375
 376     else:
 377       args.extend(["--resync-rate", "%d" % params[constants.LDP_RESYNC_RATE]])
 378
 379     return args
 380
 381   def GenPauseSyncCmd(self, minor):
 382     return ["drbdsetup", "pause-sync", minor]
 383
 384   def GenResumeSyncCmd(self, minor):
 385     return ["drbdsetup", "resume-sync", minor]
 386
 387   def GenPrimaryCmd(self, minor, force):
 388     cmd = ["drbdsetup", "primary", minor]
 389
 390     if force:
 391       cmd.append("--force")
 392
 393     return cmd
 394
 395   def GenSecondaryCmd(self, minor):
 396     return ["drbdsetup", "secondary", minor]
 397
 398   def GenDetachCmd(self, minor):
 399     return ["drbdsetup", "detach", minor]
 400
 401   def GenDisconnectCmd(self, minor, family, lhost, lport, rhost, rport):
 402     return ["drbdsetup", "disconnect",
 403             "%s:%s:%s" % (family, lhost, lport),
 404             "%s:%s:%s" % (family, rhost, rport)]
 405
 406   def GenDownCmd(self, minor):
 407     return ["drbdsetup", "down", self._GetResource(minor)]
 408
 409   def GenResizeCmd(self, minor, size_mb):
 410     return ["drbdsetup", "resize", minor, "--size", "%dm" % size_mb]
 411
 412   @staticmethod
 413   def _GetResource(minor):
 414     """Return the resource name for a given minor.
 415
 416     Currently we don't support DRBD volumes which share a resource, so we
 417     generate the resource name based on the minor the resulting volumes is
 418     assigned to.
 419
 420     """
 421     return "resource%d" % minor
 422
 423   @classmethod
 424   def _ComputeDiskBarrierArgs(cls, disabled_barriers, disable_meta_flush):
 425     """Compute the DRBD command line parameters for disk barriers
 426
 427     """
 428     disabled_barriers_set = frozenset(disabled_barriers)
 429     if not disabled_barriers_set in constants.DRBD_VALID_BARRIER_OPT:
 430       raise errors.BlockDeviceError("%s is not a valid option set for DRBD"
 431                                     " barriers" % disabled_barriers)
 432
 433     args = []
 434
 435     # meta flushes
 436     if disable_meta_flush:
 437       args.append(cls._DISABLE_META_FLUSH_OPTION)
 438
 439     # disk flushes
 440     if constants.DRBD_B_DISK_FLUSH in disabled_barriers_set:
 441       args.append(cls._DISABLE_FLUSH_OPTION)
 442
 443     # disk drain
 444     if constants.DRBD_B_DISK_DRAIN in disabled_barriers_set:
 445       args.append(cls._DISABLE_DRAIN_OPTION)
 446
 447     # disk barriers
 448     if constants.DRBD_B_DISK_BARRIERS in disabled_barriers_set:
 449       args.append(cls._DISABLE_DISK_OPTION)
 450
 451     return args