qa_utils.py 16.9 KB
Newer Older
1 2 3
#
#

4
# Copyright (C) 2007, 2011, 2012 Google Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.


"""Utilities for QA tests.

"""

import os
27
import re
Michael Hanselmann's avatar
Michael Hanselmann committed
28
import sys
29
import subprocess
30
import random
31
import tempfile
32

33 34 35 36 37
try:
  import functools
except ImportError, err:
  raise ImportError("Python 2.5 or higher is required: %s" % err)

38
from ganeti import utils
39
from ganeti import compat
40
from ganeti import constants
41
from ganeti import ht
42
from ganeti import pathutils
43 44 45 46 47

import qa_config
import qa_error


Michael Hanselmann's avatar
Michael Hanselmann committed
48 49 50 51 52
_INFO_SEQ = None
_WARNING_SEQ = None
_ERROR_SEQ = None
_RESET_SEQ = None

53 54
_MULTIPLEXERS = {}

55 56 57 58 59 60 61 62 63 64
#: Unique ID per QA run
_RUN_UUID = utils.NewUUID()


(INST_DOWN,
 INST_UP) = range(500, 502)

(FIRST_ARG,
 RETURN_VALUE) = range(1000, 1002)

Michael Hanselmann's avatar
Michael Hanselmann committed
65 66 67 68 69

def _SetupColours():
  """Initializes the colour constants.

  """
70
  # pylint: disable=W0603
Iustin Pop's avatar
Iustin Pop committed
71
  # due to global usage
Michael Hanselmann's avatar
Michael Hanselmann committed
72 73
  global _INFO_SEQ, _WARNING_SEQ, _ERROR_SEQ, _RESET_SEQ

74 75 76 77
  # Don't use colours if stdout isn't a terminal
  if not sys.stdout.isatty():
    return

Michael Hanselmann's avatar
Michael Hanselmann committed
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
  try:
    import curses
  except ImportError:
    # Don't use colours if curses module can't be imported
    return

  curses.setupterm()

  _RESET_SEQ = curses.tigetstr("op")

  setaf = curses.tigetstr("setaf")
  _INFO_SEQ = curses.tparm(setaf, curses.COLOR_GREEN)
  _WARNING_SEQ = curses.tparm(setaf, curses.COLOR_YELLOW)
  _ERROR_SEQ = curses.tparm(setaf, curses.COLOR_RED)


_SetupColours()


97 98 99 100 101
def AssertIn(item, sequence):
  """Raises an error when item is not in sequence.

  """
  if item not in sequence:
Iustin Pop's avatar
Iustin Pop committed
102
    raise qa_error.Error("%r not in %r" % (item, sequence))
103 104


105 106 107 108 109
def AssertNotIn(item, sequence):
  """Raises an error when item is in sequence.

  """
  if item in sequence:
Iustin Pop's avatar
Iustin Pop committed
110
    raise qa_error.Error("%r in %r" % (item, sequence))
111 112


113
def AssertEqual(first, second):
114 115 116 117
  """Raises an error when values aren't equal.

  """
  if not first == second:
Iustin Pop's avatar
Iustin Pop committed
118
    raise qa_error.Error("%r == %r" % (first, second))
119 120


121 122 123 124 125 126 127 128
def AssertMatch(string, pattern):
  """Raises an error when string doesn't match regexp pattern.

  """
  if not re.match(pattern, string):
    raise qa_error.Error("%r doesn't match /%r/" % (string, pattern))


129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
def _GetName(entity, key):
  """Tries to get name of an entity.

  @type entity: string or dict
  @type key: string
  @param key: Dictionary key containing name

  """
  if isinstance(entity, basestring):
    result = entity
  elif isinstance(entity, dict):
    result = entity[key]
  else:
    raise qa_error.Error("Expected string or dictionary, got %s: %s" %
                         (type(entity), entity))

  if not ht.TNonEmptyString(result):
    raise Exception("Invalid name '%s'" % result)

  return result


Iustin Pop's avatar
Iustin Pop committed
151 152 153 154 155 156 157 158 159 160
def AssertCommand(cmd, fail=False, node=None):
  """Checks that a remote command succeeds.

  @param cmd: either a string (the command to execute) or a list (to
      be converted using L{utils.ShellQuoteArgs} into a string)
  @type fail: boolean
  @param fail: if the command is expected to fail instead of succeeding
  @param node: if passed, it should be the node on which the command
      should be executed, instead of the master node (can be either a
      dict or a string)
161 162
  @return: the return code of the command
  @raise qa_error.Error: if the command fails when it shouldn't or vice versa
Iustin Pop's avatar
Iustin Pop committed
163 164 165 166 167

  """
  if node is None:
    node = qa_config.GetMasterNode()

168
  nodename = _GetName(node, "primary")
Iustin Pop's avatar
Iustin Pop committed
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185

  if isinstance(cmd, basestring):
    cmdstr = cmd
  else:
    cmdstr = utils.ShellQuoteArgs(cmd)

  rcode = StartSSH(nodename, cmdstr).wait()

  if fail:
    if rcode == 0:
      raise qa_error.Error("Command '%s' on node %s was expected to fail but"
                           " didn't" % (cmdstr, nodename))
  else:
    if rcode != 0:
      raise qa_error.Error("Command '%s' on node %s failed, exit code %s" %
                           (cmdstr, nodename, rcode))

186 187
  return rcode

Iustin Pop's avatar
Iustin Pop committed
188

Iustin Pop's avatar
Iustin Pop committed
189
def GetSSHCommand(node, cmd, strict=True, opts=None, tty=None):
190 191
  """Builds SSH command to be executed.

192 193 194
  @type node: string
  @param node: node the command should run on
  @type cmd: string
195 196
  @param cmd: command to be executed in the node; if None or empty
      string, no command will be executed
197 198
  @type strict: boolean
  @param strict: whether to enable strict host key checking
199 200
  @type opts: list
  @param opts: list of additional options
Iustin Pop's avatar
Iustin Pop committed
201 202
  @type tty: boolean or None
  @param tty: if we should use tty; if None, will be auto-detected
203

204
  """
205
  args = ["ssh", "-oEscapeChar=none", "-oBatchMode=yes", "-lroot"]
206

Iustin Pop's avatar
Iustin Pop committed
207 208 209
  if tty is None:
    tty = sys.stdout.isatty()

210 211
  if tty:
    args.append("-t")
212 213

  if strict:
Iustin Pop's avatar
Iustin Pop committed
214
    tmp = "yes"
215
  else:
Iustin Pop's avatar
Iustin Pop committed
216 217 218 219
    tmp = "no"
  args.append("-oStrictHostKeyChecking=%s" % tmp)
  args.append("-oClearAllForwardings=yes")
  args.append("-oForwardAgent=yes")
220 221 222 223
  if opts:
    args.extend(opts)
  if node in _MULTIPLEXERS:
    spath = _MULTIPLEXERS[node][0]
Iustin Pop's avatar
Iustin Pop committed
224 225
    args.append("-oControlPath=%s" % spath)
    args.append("-oControlMaster=no")
226
  args.append(node)
227 228
  if cmd:
    args.append(cmd)
229 230 231 232

  return args


233
def StartLocalCommand(cmd, _nolog_opts=False, **kwargs):
234 235 236
  """Starts a local command.

  """
237 238 239 240 241
  if _nolog_opts:
    pcmd = [i for i in cmd if not i.startswith("-")]
  else:
    pcmd = cmd
  print "Command: %s" % utils.ShellQuoteArgs(pcmd)
242 243 244
  return subprocess.Popen(cmd, shell=False, **kwargs)


245 246 247 248
def StartSSH(node, cmd, strict=True):
  """Starts SSH.

  """
249 250
  return StartLocalCommand(GetSSHCommand(node, cmd, strict=strict),
                           _nolog_opts=True)
251 252


253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
def StartMultiplexer(node):
  """Starts a multiplexer command.

  @param node: the node for which to open the multiplexer

  """
  if node in _MULTIPLEXERS:
    return

  # Note: yes, we only need mktemp, since we'll remove the file anyway
  sname = tempfile.mktemp(prefix="ganeti-qa-multiplexer.")
  utils.RemoveFile(sname)
  opts = ["-N", "-oControlPath=%s" % sname, "-oControlMaster=yes"]
  print "Created socket at %s" % sname
  child = StartLocalCommand(GetSSHCommand(node, None, opts=opts))
  _MULTIPLEXERS[node] = (sname, child)


def CloseMultiplexers():
  """Closes all current multiplexers and cleans up.

  """
  for node in _MULTIPLEXERS.keys():
    (sname, child) = _MULTIPLEXERS.pop(node)
    utils.KillProcess(child.pid, timeout=10, waitpid=True)
    utils.RemoveFile(sname)


Iustin Pop's avatar
Iustin Pop committed
281
def GetCommandOutput(node, cmd, tty=None):
282 283 284
  """Returns the output of a command executed on the given node.

  """
285 286
  p = StartLocalCommand(GetSSHCommand(node, cmd, tty=tty),
                        stdout=subprocess.PIPE)
287 288
  AssertEqual(p.wait(), 0)
  return p.stdout.read()
289 290 291 292 293 294 295


def UploadFile(node, src):
  """Uploads a file to a node and returns the filename.

  Caller needs to remove the returned file on the node when it's not needed
  anymore.
296

297 298 299 300 301 302 303 304 305
  """
  # Make sure nobody else has access to it while preserving local permissions
  mode = os.stat(src).st_mode & 0700

  cmd = ('tmp=$(tempfile --mode %o --prefix gnt) && '
         '[[ -f "${tmp}" ]] && '
         'cat > "${tmp}" && '
         'echo "${tmp}"') % mode

Iustin Pop's avatar
Iustin Pop committed
306
  f = open(src, "r")
307 308 309 310 311 312 313 314 315
  try:
    p = subprocess.Popen(GetSSHCommand(node, cmd), shell=False, stdin=f,
                         stdout=subprocess.PIPE)
    AssertEqual(p.wait(), 0)

    # Return temporary filename
    return p.stdout.read().strip()
  finally:
    f.close()
Michael Hanselmann's avatar
Michael Hanselmann committed
316 317


318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
def UploadData(node, data, mode=0600, filename=None):
  """Uploads data to a node and returns the filename.

  Caller needs to remove the returned file on the node when it's not needed
  anymore.

  """
  if filename:
    tmp = "tmp=%s" % utils.ShellQuote(filename)
  else:
    tmp = "tmp=$(tempfile --mode %o --prefix gnt)" % mode
  cmd = ("%s && "
         "[[ -f \"${tmp}\" ]] && "
         "cat > \"${tmp}\" && "
         "echo \"${tmp}\"") % tmp

  p = subprocess.Popen(GetSSHCommand(node, cmd), shell=False,
                       stdin=subprocess.PIPE, stdout=subprocess.PIPE)
  p.stdin.write(data)
  p.stdin.close()
  AssertEqual(p.wait(), 0)

  # Return temporary filename
  return p.stdout.read().strip()


344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
def BackupFile(node, path):
  """Creates a backup of a file on the node and returns the filename.

  Caller needs to remove the returned file on the node when it's not needed
  anymore.

  """
  cmd = ("tmp=$(tempfile --prefix .gnt --directory=$(dirname %s)) && "
         "[[ -f \"$tmp\" ]] && "
         "cp %s $tmp && "
         "echo $tmp") % (utils.ShellQuote(path), utils.ShellQuote(path))

  # Return temporary filename
  return GetCommandOutput(node, cmd).strip()


360 361 362 363 364 365
def _ResolveName(cmd, key):
  """Helper function.

  """
  master = qa_config.GetMasterNode()

Iustin Pop's avatar
Iustin Pop committed
366
  output = GetCommandOutput(master["primary"], utils.ShellQuoteArgs(cmd))
367
  for line in output.splitlines():
Iustin Pop's avatar
Iustin Pop committed
368
    (lkey, lvalue) = line.split(":", 1)
369 370 371 372 373
    if lkey == key:
      return lvalue.lstrip()
  raise KeyError("Key not found")


Michael Hanselmann's avatar
Michael Hanselmann committed
374 375 376
def ResolveInstanceName(instance):
  """Gets the full name of an instance.

377 378 379
  @type instance: string
  @param instance: Instance name

380
  """
Iustin Pop's avatar
Iustin Pop committed
381 382
  return _ResolveName(["gnt-instance", "info", instance],
                      "Instance name")
383 384 385 386 387 388


def ResolveNodeName(node):
  """Gets the full name of a node.

  """
Iustin Pop's avatar
Iustin Pop committed
389 390
  return _ResolveName(["gnt-node", "info", node["primary"]],
                      "Node name")
391 392 393 394 395


def GetNodeInstances(node, secondaries=False):
  """Gets a list of instances on a node.

Michael Hanselmann's avatar
Michael Hanselmann committed
396 397
  """
  master = qa_config.GetMasterNode()
398
  node_name = ResolveNodeName(node)
Michael Hanselmann's avatar
Michael Hanselmann committed
399

400
  # Get list of all instances
Iustin Pop's avatar
Iustin Pop committed
401 402 403
  cmd = ["gnt-instance", "list", "--separator=:", "--no-headers",
         "--output=name,pnode,snodes"]
  output = GetCommandOutput(master["primary"], utils.ShellQuoteArgs(cmd))
404 405 406

  instances = []
  for line in output.splitlines():
Iustin Pop's avatar
Iustin Pop committed
407
    (name, pnode, snodes) = line.split(":", 2)
408
    if ((not secondaries and pnode == node_name) or
Iustin Pop's avatar
Iustin Pop committed
409
        (secondaries and node_name in snodes.split(","))):
410
      instances.append(name)
Michael Hanselmann's avatar
Michael Hanselmann committed
411

412
  return instances
Michael Hanselmann's avatar
Michael Hanselmann committed
413 414


415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
def _SelectQueryFields(rnd, fields):
  """Generates a list of fields for query tests.

  """
  # Create copy for shuffling
  fields = list(fields)
  rnd.shuffle(fields)

  # Check all fields
  yield fields
  yield sorted(fields)

  # Duplicate fields
  yield fields + fields

  # Check small groups of fields
  while fields:
    yield [fields.pop() for _ in range(rnd.randint(2, 10)) if fields]


def _List(listcmd, fields, names):
  """Runs a list command.

  """
  master = qa_config.GetMasterNode()

441
  cmd = [listcmd, "list", "--separator=|", "--no-headers",
442 443 444 445 446 447 448 449 450
         "--output", ",".join(fields)]

  if names:
    cmd.extend(names)

  return GetCommandOutput(master["primary"],
                          utils.ShellQuoteArgs(cmd)).splitlines()


451
def GenericQueryTest(cmd, fields, namefield="name", test_unknown=True):
452 453 454 455 456 457 458 459
  """Runs a number of tests on query commands.

  @param cmd: Command name
  @param fields: List of field names

  """
  rnd = random.Random(hash(cmd))

Iustin Pop's avatar
Iustin Pop committed
460
  fields = list(fields)
461 462 463 464 465 466
  rnd.shuffle(fields)

  # Test a number of field combinations
  for testfields in _SelectQueryFields(rnd, fields):
    AssertCommand([cmd, "list", "--output", ",".join(testfields)])

467 468
  if namefield is not None:
    namelist_fn = compat.partial(_List, cmd, [namefield])
469

470 471 472
    # When no names were requested, the list must be sorted
    names = namelist_fn(None)
    AssertEqual(names, utils.NiceSort(names))
473

474 475 476
    # When requesting specific names, the order must be kept
    revnames = list(reversed(names))
    AssertEqual(namelist_fn(revnames), revnames)
477

478 479 480
    randnames = list(names)
    rnd.shuffle(randnames)
    AssertEqual(namelist_fn(randnames), randnames)
481

482 483 484 485
  if test_unknown:
    # Listing unknown items must fail
    AssertCommand([cmd, "list", "this.name.certainly.does.not.exist"],
                  fail=True)
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504

  # Check exit code for listing unknown field
  AssertEqual(AssertCommand([cmd, "list", "--output=field/does/not/exist"],
                            fail=True),
              constants.EXIT_UNKNOWN_FIELD)


def GenericQueryFieldsTest(cmd, fields):
  master = qa_config.GetMasterNode()

  # Listing fields
  AssertCommand([cmd, "list-fields"])
  AssertCommand([cmd, "list-fields"] + fields)

  # Check listed fields (all, must be sorted)
  realcmd = [cmd, "list-fields", "--separator=|", "--no-headers"]
  output = GetCommandOutput(master["primary"],
                            utils.ShellQuoteArgs(realcmd)).splitlines()
  AssertEqual([line.split("|", 1)[0] for line in output],
505
              utils.NiceSort(fields))
506 507 508 509 510 511

  # Check exit code for listing unknown field
  AssertEqual(AssertCommand([cmd, "list-fields", "field/does/not/exist"],
                            fail=True),
              constants.EXIT_UNKNOWN_FIELD)

512

513 514 515 516
def _FormatWithColor(text, seq):
  if not seq:
    return text
  return "%s%s%s" % (seq, text, _RESET_SEQ)
Michael Hanselmann's avatar
Michael Hanselmann committed
517 518


519 520 521
FormatWarning = lambda text: _FormatWithColor(text, _WARNING_SEQ)
FormatError = lambda text: _FormatWithColor(text, _ERROR_SEQ)
FormatInfo = lambda text: _FormatWithColor(text, _INFO_SEQ)
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537


def AddToEtcHosts(hostnames):
  """Adds hostnames to /etc/hosts.

  @param hostnames: List of hostnames first used A records, all other CNAMEs

  """
  master = qa_config.GetMasterNode()
  tmp_hosts = UploadData(master["primary"], "", mode=0644)

  data = []
  for localhost in ("::1", "127.0.0.1"):
    data.append("%s %s" % (localhost, " ".join(hostnames)))

  try:
538 539 540 541 542 543 544 545 546
    AssertCommand("{ cat %s && echo -e '%s'; } > %s && mv %s %s" %
                  (utils.ShellQuote(pathutils.ETC_HOSTS),
                   "\\n".join(data),
                   utils.ShellQuote(tmp_hosts),
                   utils.ShellQuote(tmp_hosts),
                   utils.ShellQuote(pathutils.ETC_HOSTS)))
  except Exception:
    AssertCommand(["rm", "-f", tmp_hosts])
    raise
547 548 549 550 551 552 553 554 555 556 557 558 559 560


def RemoveFromEtcHosts(hostnames):
  """Remove hostnames from /etc/hosts.

  @param hostnames: List of hostnames first used A records, all other CNAMEs

  """
  master = qa_config.GetMasterNode()
  tmp_hosts = UploadData(master["primary"], "", mode=0644)
  quoted_tmp_hosts = utils.ShellQuote(tmp_hosts)

  sed_data = " ".join(hostnames)
  try:
561 562 563 564 565 566 567 568
    AssertCommand(("sed -e '/^\(::1\|127\.0\.0\.1\)\s\+%s/d' %s > %s"
                   " && mv %s %s") %
                   (sed_data, utils.ShellQuote(pathutils.ETC_HOSTS),
                    quoted_tmp_hosts, quoted_tmp_hosts,
                    utils.ShellQuote(pathutils.ETC_HOSTS)))
  except Exception:
    AssertCommand(["rm", "-f", tmp_hosts])
    raise
569 570 571 572 573 574


def RunInstanceCheck(instance, running):
  """Check if instance is running or not.

  """
575
  instance_name = _GetName(instance, "name")
576

577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
  script = qa_config.GetInstanceCheckScript()
  if not script:
    return

  master_node = qa_config.GetMasterNode()

  # Build command to connect to master node
  master_ssh = GetSSHCommand(master_node["primary"], "--")

  if running:
    running_shellval = "1"
    running_text = ""
  else:
    running_shellval = ""
    running_text = "not "

  print FormatInfo("Checking if instance '%s' is %srunning" %
                   (instance_name, running_text))

  args = [script, instance_name]
  env = {
    "PATH": constants.HOOKS_PATH,
    "RUN_UUID": _RUN_UUID,
    "MASTER_SSH": utils.ShellQuoteArgs(master_ssh),
    "INSTANCE_NAME": instance_name,
    "INSTANCE_RUNNING": running_shellval,
    }

  result = os.spawnve(os.P_WAIT, script, args, env)
  if result != 0:
    raise qa_error.Error("Instance check failed with result %s" % result)


def _InstanceCheckInner(expected, instarg, args, result):
  """Helper function used by L{InstanceCheck}.

  """
  if instarg == FIRST_ARG:
    instance = args[0]
  elif instarg == RETURN_VALUE:
    instance = result
  else:
    raise Exception("Invalid value '%s' for instance argument" % instarg)

  if expected in (INST_DOWN, INST_UP):
    RunInstanceCheck(instance, (expected == INST_UP))
  elif expected is not None:
    raise Exception("Invalid value '%s'" % expected)


def InstanceCheck(before, after, instarg):
  """Decorator to check instance status before and after test.

  @param before: L{INST_DOWN} if instance must be stopped before test,
    L{INST_UP} if instance must be running before test, L{None} to not check.
  @param after: L{INST_DOWN} if instance must be stopped after test,
    L{INST_UP} if instance must be running after test, L{None} to not check.
  @param instarg: L{FIRST_ARG} to use first argument to test as instance (a
    dictionary), L{RETURN_VALUE} to use return value (disallows pre-checks)

  """
  def decorator(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
      _InstanceCheckInner(before, instarg, args, NotImplemented)

      result = fn(*args, **kwargs)

      _InstanceCheckInner(after, instarg, args, result)

      return result
    return wrapper
  return decorator