code.grnet.gr Git - ganeti-local/blob - qa/qa_instance.py

   1 #
   2 #
   3
   4 # Copyright (C) 2007 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 """Instance related QA tests.
  23
  24 """
  25
  26 import re
  27 import time
  28
  29 from ganeti import utils
  30 from ganeti import constants
  31
  32 import qa_config
  33 import qa_utils
  34 import qa_error
  35
  36 from qa_utils import AssertEqual, AssertNotEqual, StartSSH
  37
  38
  39 def _GetDiskStatePath(disk):
  40   return "/sys/block/%s/device/state" % disk
  41
  42
  43 def _GetGenericAddParameters():
  44   params = ['-B', '%s=%s' % (constants.BE_MEMORY, qa_config.get('mem'))]
  45   for idx, size in enumerate(qa_config.get('disk')):
  46     params.extend(["--disk", "%s:size=%s" % (idx, size)])
  47   return params
  48
  49
  50 def _DiskTest(node, disk_template):
  51   master = qa_config.GetMasterNode()
  52
  53   instance = qa_config.AcquireInstance()
  54   try:
  55     cmd = (['gnt-instance', 'add',
  56             '--os-type=%s' % qa_config.get('os'),
  57             '--disk-template=%s' % disk_template,
  58             '--node=%s' % node] +
  59            _GetGenericAddParameters())
  60     cmd.append(instance['name'])
  61
  62     AssertEqual(StartSSH(master['primary'],
  63                          utils.ShellQuoteArgs(cmd)).wait(), 0)
  64     return instance
  65   except:
  66     qa_config.ReleaseInstance(instance)
  67     raise
  68
  69
  70 def TestInstanceAddWithPlainDisk(node):
  71   """gnt-instance add -t plain"""
  72   return _DiskTest(node['primary'], 'plain')
  73
  74
  75 def TestInstanceAddWithDrbdDisk(node, node2):
  76   """gnt-instance add -t drbd"""
  77   return _DiskTest("%s:%s" % (node['primary'], node2['primary']),
  78                    'drbd')
  79
  80
  81 def TestInstanceRemove(instance):
  82   """gnt-instance remove"""
  83   master = qa_config.GetMasterNode()
  84
  85   cmd = ['gnt-instance', 'remove', '-f', instance['name']]
  86   AssertEqual(StartSSH(master['primary'],
  87                        utils.ShellQuoteArgs(cmd)).wait(), 0)
  88
  89   qa_config.ReleaseInstance(instance)
  90
  91
  92 def TestInstanceStartup(instance):
  93   """gnt-instance startup"""
  94   master = qa_config.GetMasterNode()
  95
  96   cmd = ['gnt-instance', 'startup', instance['name']]
  97   AssertEqual(StartSSH(master['primary'],
  98                        utils.ShellQuoteArgs(cmd)).wait(), 0)
  99
 100
 101 def TestInstanceShutdown(instance):
 102   """gnt-instance shutdown"""
 103   master = qa_config.GetMasterNode()
 104
 105   cmd = ['gnt-instance', 'shutdown', instance['name']]
 106   AssertEqual(StartSSH(master['primary'],
 107                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 108
 109
 110 def TestInstanceReboot(instance):
 111   """gnt-instance reboot"""
 112   master = qa_config.GetMasterNode()
 113
 114   for reboottype in ["soft", "hard", "full"]:
 115     cmd = ['gnt-instance', 'reboot', '--type=%s' % reboottype,
 116            instance['name']]
 117     AssertEqual(StartSSH(master['primary'],
 118                          utils.ShellQuoteArgs(cmd)).wait(), 0)
 119
 120
 121 def TestInstanceReinstall(instance):
 122   """gnt-instance reinstall"""
 123   master = qa_config.GetMasterNode()
 124
 125   cmd = ['gnt-instance', 'reinstall', '-f', instance['name']]
 126   AssertEqual(StartSSH(master['primary'],
 127                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 128
 129
 130 def TestInstanceFailover(instance):
 131   """gnt-instance failover"""
 132   master = qa_config.GetMasterNode()
 133
 134   cmd = ['gnt-instance', 'failover', '--force', instance['name']]
 135   AssertEqual(StartSSH(master['primary'],
 136                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 137
 138   # ... and back
 139   cmd = ['gnt-instance', 'failover', '--force', instance['name']]
 140   AssertEqual(StartSSH(master['primary'],
 141                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 142
 143
 144 def TestInstanceInfo(instance):
 145   """gnt-instance info"""
 146   master = qa_config.GetMasterNode()
 147
 148   cmd = ['gnt-instance', 'info', instance['name']]
 149   AssertEqual(StartSSH(master['primary'],
 150                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 151
 152
 153 def TestInstanceModify(instance):
 154   """gnt-instance modify"""
 155   master = qa_config.GetMasterNode()
 156
 157   # Assume /sbin/init exists on all systems
 158   test_kernel = "/sbin/init"
 159   test_initrd = test_kernel
 160
 161   orig_memory = qa_config.get('mem')
 162   orig_bridge = qa_config.get('bridge', 'xen-br0')
 163   args = [
 164     ["-B", "%s=128" % constants.BE_MEMORY],
 165     ["-B", "%s=%s" % (constants.BE_MEMORY, orig_memory)],
 166     ["-B", "%s=2" % constants.BE_VCPUS],
 167     ["-B", "%s=1" % constants.BE_VCPUS],
 168     ["-B", "%s=%s" % (constants.BE_VCPUS, constants.VALUE_DEFAULT)],
 169
 170     ["-H", "%s=%s" % (constants.HV_KERNEL_PATH, test_kernel)],
 171     ["-H", "%s=%s" % (constants.HV_KERNEL_PATH, constants.VALUE_DEFAULT)],
 172     ["-H", "%s=%s" % (constants.HV_INITRD_PATH, test_initrd)],
 173     ["-H", "no_%s" % (constants.HV_INITRD_PATH, )],
 174     ["-H", "%s=%s" % (constants.HV_INITRD_PATH, constants.VALUE_DEFAULT)],
 175
 176     # TODO: bridge tests
 177     #["--bridge", "xen-br1"],
 178     #["--bridge", orig_bridge],
 179
 180     # TODO: Do these tests only with xen-hvm
 181     #["-H", "%s=acn" % constants.HV_BOOT_ORDER],
 182     #["-H", "%s=%s" % (constants.HV_BOOT_ORDER, constants.VALUE_DEFAULT)],
 183     ]
 184   for alist in args:
 185     cmd = ['gnt-instance', 'modify'] + alist + [instance['name']]
 186     AssertEqual(StartSSH(master['primary'],
 187                          utils.ShellQuoteArgs(cmd)).wait(), 0)
 188
 189   # check no-modify
 190   cmd = ['gnt-instance', 'modify', instance['name']]
 191   AssertNotEqual(StartSSH(master['primary'],
 192                           utils.ShellQuoteArgs(cmd)).wait(), 0)
 193
 194
 195 def TestInstanceList():
 196   """gnt-instance list"""
 197   master = qa_config.GetMasterNode()
 198
 199   cmd = ['gnt-instance', 'list']
 200   AssertEqual(StartSSH(master['primary'],
 201                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 202
 203
 204 def TestInstanceConsole(instance):
 205   """gnt-instance console"""
 206   master = qa_config.GetMasterNode()
 207
 208   cmd = ['gnt-instance', 'console', '--show-cmd', instance['name']]
 209   AssertEqual(StartSSH(master['primary'],
 210                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 211
 212
 213 def TestReplaceDisks(instance, pnode, snode, othernode):
 214   """gnt-instance replace-disks"""
 215   master = qa_config.GetMasterNode()
 216
 217   def buildcmd(args):
 218     cmd = ['gnt-instance', 'replace-disks']
 219     cmd.extend(args)
 220     cmd.append(instance["name"])
 221     return cmd
 222
 223   cmd = buildcmd(["-p"])
 224   AssertEqual(StartSSH(master['primary'],
 225                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 226
 227   cmd = buildcmd(["-s"])
 228   AssertEqual(StartSSH(master['primary'],
 229                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 230
 231   cmd = buildcmd(["--new-secondary=%s" % othernode["primary"]])
 232   AssertEqual(StartSSH(master['primary'],
 233                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 234
 235   # Restore
 236   cmd = buildcmd(["--new-secondary=%s" % snode["primary"]])
 237   AssertEqual(StartSSH(master['primary'],
 238                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 239
 240
 241 def TestInstanceExport(instance, node):
 242   """gnt-backup export"""
 243   master = qa_config.GetMasterNode()
 244
 245   cmd = ['gnt-backup', 'export', '-n', node['primary'], instance['name']]
 246   AssertEqual(StartSSH(master['primary'],
 247                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 248
 249   return qa_utils.ResolveInstanceName(instance)
 250
 251
 252 def TestInstanceImport(node, newinst, expnode, name):
 253   """gnt-backup import"""
 254   master = qa_config.GetMasterNode()
 255
 256   cmd = (['gnt-backup', 'import',
 257           '--disk-template=plain',
 258           '--no-ip-check',
 259           '--src-node=%s' % expnode['primary'],
 260           '--src-dir=%s/%s' % (constants.EXPORT_DIR, name),
 261           '--node=%s' % node['primary']] +
 262          _GetGenericAddParameters())
 263   cmd.append(newinst['name'])
 264   AssertEqual(StartSSH(master['primary'],
 265                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 266
 267
 268 def TestBackupList(expnode):
 269   """gnt-backup list"""
 270   master = qa_config.GetMasterNode()
 271
 272   cmd = ['gnt-backup', 'list', '--node=%s' % expnode['primary']]
 273   AssertEqual(StartSSH(master['primary'],
 274                        utils.ShellQuoteArgs(cmd)).wait(), 0)
 275
 276
 277 def _TestInstanceDiskFailure(instance, node, node2, onmaster):
 278   """Testing disk failure."""
 279   master = qa_config.GetMasterNode()
 280   sq = utils.ShellQuoteArgs
 281
 282   instance_full = qa_utils.ResolveInstanceName(instance)
 283   node_full = qa_utils.ResolveNodeName(node)
 284   node2_full = qa_utils.ResolveNodeName(node2)
 285
 286   print qa_utils.FormatInfo("Getting physical disk names")
 287   cmd = ['gnt-node', 'volumes', '--separator=|', '--no-headers',
 288          '--output=node,phys,instance',
 289          node['primary'], node2['primary']]
 290   output = qa_utils.GetCommandOutput(master['primary'], sq(cmd))
 291
 292   # Get physical disk names
 293   re_disk = re.compile(r'^/dev/([a-z]+)\d+$')
 294   node2disk = {}
 295   for line in output.splitlines():
 296     (node_name, phys, inst) = line.split('|')
 297     if inst == instance_full:
 298       if node_name not in node2disk:
 299         node2disk[node_name] = []
 300
 301       m = re_disk.match(phys)
 302       if not m:
 303         raise qa_error.Error("Unknown disk name format: %s" % disk)
 304
 305       name = m.group(1)
 306       if name not in node2disk[node_name]:
 307         node2disk[node_name].append(name)
 308
 309   if [node2_full, node_full][int(onmaster)] not in node2disk:
 310     raise qa_error.Error("Couldn't find physical disks used on"
 311                          " %s node" % ["secondary", "master"][int(onmaster)])
 312
 313   print qa_utils.FormatInfo("Checking whether nodes have ability to stop"
 314                             " disks")
 315   for node_name, disks in node2disk.iteritems():
 316     cmds = []
 317     for disk in disks:
 318       cmds.append(sq(["test", "-f", _GetDiskStatePath(disk)]))
 319     AssertEqual(StartSSH(node_name, ' && '.join(cmds)).wait(), 0)
 320
 321   print qa_utils.FormatInfo("Getting device paths")
 322   cmd = ['gnt-instance', 'activate-disks', instance['name']]
 323   output = qa_utils.GetCommandOutput(master['primary'], sq(cmd))
 324   devpath = []
 325   for line in output.splitlines():
 326     (_, _, tmpdevpath) = line.split(':')
 327     devpath.append(tmpdevpath)
 328   print devpath
 329
 330   print qa_utils.FormatInfo("Getting drbd device paths")
 331   cmd = ['gnt-instance', 'info', instance['name']]
 332   output = qa_utils.GetCommandOutput(master['primary'], sq(cmd))
 333   pattern = (r'\s+-\s+sd[a-z]+,\s+type:\s+drbd8?,\s+.*$'
 334              r'\s+primary:\s+(/dev/drbd\d+)\s+')
 335   drbddevs = re.findall(pattern, output, re.M)
 336   print drbddevs
 337
 338   halted_disks = []
 339   try:
 340     print qa_utils.FormatInfo("Deactivating disks")
 341     cmds = []
 342     for name in node2disk[[node2_full, node_full][int(onmaster)]]:
 343       halted_disks.append(name)
 344       cmds.append(sq(["echo", "offline"]) + " >%s" % _GetDiskStatePath(name))
 345     AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
 346                          ' && '.join(cmds)).wait(), 0)
 347
 348     print qa_utils.FormatInfo("Write to disks and give some time to notice"
 349                               " to notice the problem")
 350     cmds = []
 351     for disk in devpath:
 352       cmds.append(sq(["dd", "count=1", "bs=512", "conv=notrunc",
 353                       "if=%s" % disk, "of=%s" % disk]))
 354     for _ in (0, 1, 2):
 355       AssertEqual(StartSSH(node['primary'], ' && '.join(cmds)).wait(), 0)
 356       time.sleep(3)
 357
 358     print qa_utils.FormatInfo("Debugging info")
 359     for name in drbddevs:
 360       cmd = ['drbdsetup', name, 'show']
 361       AssertEqual(StartSSH(node['primary'], sq(cmd)).wait(), 0)
 362
 363     cmd = ['gnt-instance', 'info', instance['name']]
 364     AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
 365
 366   finally:
 367     print qa_utils.FormatInfo("Activating disks again")
 368     cmds = []
 369     for name in halted_disks:
 370       cmds.append(sq(["echo", "running"]) + " >%s" % _GetDiskStatePath(name))
 371     AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
 372                          '; '.join(cmds)).wait(), 0)
 373
 374   if onmaster:
 375     for name in drbddevs:
 376       cmd = ['drbdsetup', name, 'detach']
 377       AssertEqual(StartSSH(node['primary'], sq(cmd)).wait(), 0)
 378   else:
 379     for name in drbddevs:
 380       cmd = ['drbdsetup', name, 'disconnect']
 381       AssertEqual(StartSSH(node2['primary'], sq(cmd)).wait(), 0)
 382
 383   # TODO
 384   #cmd = ['vgs']
 385   #AssertEqual(StartSSH([node2, node][int(onmaster)]['primary'],
 386   #                     sq(cmd)).wait(), 0)
 387
 388   print qa_utils.FormatInfo("Making sure disks are up again")
 389   cmd = ['gnt-instance', 'replace-disks', instance['name']]
 390   AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
 391
 392   print qa_utils.FormatInfo("Restarting instance")
 393   cmd = ['gnt-instance', 'shutdown', instance['name']]
 394   AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
 395
 396   cmd = ['gnt-instance', 'startup', instance['name']]
 397   AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
 398
 399   cmd = ['gnt-cluster', 'verify']
 400   AssertEqual(StartSSH(master['primary'], sq(cmd)).wait(), 0)
 401
 402
 403 def TestInstanceMasterDiskFailure(instance, node, node2):
 404   """Testing disk failure on master node."""
 405   print qa_utils.FormatError("Disk failure on primary node cannot be"
 406                              " tested due to potential crashes.")
 407   # The following can cause crashes, thus it's disabled until fixed
 408   #return _TestInstanceDiskFailure(instance, node, node2, True)
 409
 410
 411 def TestInstanceSecondaryDiskFailure(instance, node, node2):
 412   """Testing disk failure on secondary node."""
 413   return _TestInstanceDiskFailure(instance, node, node2, False)