Statistics
| Branch: | Tag: | Revision:

root / qa / qa_utils.py @ ec996117

History | View | Annotate | Download (24.1 kB)

1
#
2
#
3

    
4
# Copyright (C) 2007, 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
"""Utilities for QA tests.
23

24
"""
25

    
26
import copy
27
import operator
28
import os
29
import random
30
import re
31
import subprocess
32
import sys
33
import tempfile
34
import yaml
35

    
36
try:
37
  import functools
38
except ImportError, err:
39
  raise ImportError("Python 2.5 or higher is required: %s" % err)
40

    
41
from ganeti import utils
42
from ganeti import compat
43
from ganeti import constants
44
from ganeti import ht
45
from ganeti import pathutils
46
from ganeti import vcluster
47

    
48
import qa_config
49
import qa_error
50

    
51

    
52
_INFO_SEQ = None
53
_WARNING_SEQ = None
54
_ERROR_SEQ = None
55
_RESET_SEQ = None
56

    
57
_MULTIPLEXERS = {}
58

    
59
#: Unique ID per QA run
60
_RUN_UUID = utils.NewUUID()
61

    
62
#: Path to the QA query output log file
63
_QA_OUTPUT = pathutils.GetLogFilename("qa-output")
64

    
65

    
66
(INST_DOWN,
67
 INST_UP) = range(500, 502)
68

    
69
(FIRST_ARG,
70
 RETURN_VALUE) = range(1000, 1002)
71

    
72

    
73
def _SetupColours():
74
  """Initializes the colour constants.
75

76
  """
77
  # pylint: disable=W0603
78
  # due to global usage
79
  global _INFO_SEQ, _WARNING_SEQ, _ERROR_SEQ, _RESET_SEQ
80

    
81
  # Don't use colours if stdout isn't a terminal
82
  if not sys.stdout.isatty():
83
    return
84

    
85
  try:
86
    import curses
87
  except ImportError:
88
    # Don't use colours if curses module can't be imported
89
    return
90

    
91
  curses.setupterm()
92

    
93
  _RESET_SEQ = curses.tigetstr("op")
94

    
95
  setaf = curses.tigetstr("setaf")
96
  _INFO_SEQ = curses.tparm(setaf, curses.COLOR_GREEN)
97
  _WARNING_SEQ = curses.tparm(setaf, curses.COLOR_YELLOW)
98
  _ERROR_SEQ = curses.tparm(setaf, curses.COLOR_RED)
99

    
100

    
101
_SetupColours()
102

    
103

    
104
def AssertIn(item, sequence):
105
  """Raises an error when item is not in sequence.
106

107
  """
108
  if item not in sequence:
109
    raise qa_error.Error("%r not in %r" % (item, sequence))
110

    
111

    
112
def AssertNotIn(item, sequence):
113
  """Raises an error when item is in sequence.
114

115
  """
116
  if item in sequence:
117
    raise qa_error.Error("%r in %r" % (item, sequence))
118

    
119

    
120
def AssertEqual(first, second):
121
  """Raises an error when values aren't equal.
122

123
  """
124
  if not first == second:
125
    raise qa_error.Error("%r == %r" % (first, second))
126

    
127

    
128
def AssertMatch(string, pattern):
129
  """Raises an error when string doesn't match regexp pattern.
130

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

    
135

    
136
def _GetName(entity, fn):
137
  """Tries to get name of an entity.
138

139
  @type entity: string or dict
140
  @param fn: Function retrieving name from entity
141

142
  """
143
  if isinstance(entity, basestring):
144
    result = entity
145
  else:
146
    result = fn(entity)
147

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

    
151
  return result
152

    
153

    
154
def _AssertRetCode(rcode, fail, cmdstr, nodename):
155
  """Check the return value from a command and possibly raise an exception.
156

157
  """
158
  if fail and rcode == 0:
159
    raise qa_error.Error("Command '%s' on node %s was expected to fail but"
160
                         " didn't" % (cmdstr, nodename))
161
  elif not fail and rcode != 0:
162
    raise qa_error.Error("Command '%s' on node %s failed, exit code %s" %
163
                         (cmdstr, nodename, rcode))
164

    
165

    
166
def AssertCommand(cmd, fail=False, node=None, log_cmd=True):
167
  """Checks that a remote command succeeds.
168

169
  @param cmd: either a string (the command to execute) or a list (to
170
      be converted using L{utils.ShellQuoteArgs} into a string)
171
  @type fail: boolean
172
  @param fail: if the command is expected to fail instead of succeeding
173
  @param node: if passed, it should be the node on which the command
174
      should be executed, instead of the master node (can be either a
175
      dict or a string)
176
  @param log_cmd: if False, the command won't be logged (simply passed to
177
      StartSSH)
178
  @return: the return code of the command
179
  @raise qa_error.Error: if the command fails when it shouldn't or vice versa
180

181
  """
182
  if node is None:
183
    node = qa_config.GetMasterNode()
184

    
185
  nodename = _GetName(node, operator.attrgetter("primary"))
186

    
187
  if isinstance(cmd, basestring):
188
    cmdstr = cmd
189
  else:
190
    cmdstr = utils.ShellQuoteArgs(cmd)
191

    
192
  rcode = StartSSH(nodename, cmdstr, log_cmd=log_cmd).wait()
193
  _AssertRetCode(rcode, fail, cmdstr, nodename)
194

    
195
  return rcode
196

    
197

    
198
def AssertRedirectedCommand(cmd, fail=False, node=None, log_cmd=True):
199
  """Executes a command with redirected output.
200

201
  The log will go to the qa-output log file in the ganeti log
202
  directory on the node where the command is executed. The fail and
203
  node parameters are passed unchanged to AssertCommand.
204

205
  @param cmd: the command to be executed, as a list; a string is not
206
      supported
207

208
  """
209
  if not isinstance(cmd, list):
210
    raise qa_error.Error("Non-list passed to AssertRedirectedCommand")
211
  ofile = utils.ShellQuote(_QA_OUTPUT)
212
  cmdstr = utils.ShellQuoteArgs(cmd)
213
  AssertCommand("echo ---- $(date) %s ---- >> %s" % (cmdstr, ofile),
214
                fail=False, node=node, log_cmd=False)
215
  return AssertCommand(cmdstr + " >> %s" % ofile,
216
                       fail=fail, node=node, log_cmd=log_cmd)
217

    
218

    
219
def GetSSHCommand(node, cmd, strict=True, opts=None, tty=None):
220
  """Builds SSH command to be executed.
221

222
  @type node: string
223
  @param node: node the command should run on
224
  @type cmd: string
225
  @param cmd: command to be executed in the node; if None or empty
226
      string, no command will be executed
227
  @type strict: boolean
228
  @param strict: whether to enable strict host key checking
229
  @type opts: list
230
  @param opts: list of additional options
231
  @type tty: boolean or None
232
  @param tty: if we should use tty; if None, will be auto-detected
233

234
  """
235
  args = ["ssh", "-oEscapeChar=none", "-oBatchMode=yes", "-lroot"]
236

    
237
  if tty is None:
238
    tty = sys.stdout.isatty()
239

    
240
  if tty:
241
    args.append("-t")
242

    
243
  if strict:
244
    tmp = "yes"
245
  else:
246
    tmp = "no"
247
  args.append("-oStrictHostKeyChecking=%s" % tmp)
248
  args.append("-oClearAllForwardings=yes")
249
  args.append("-oForwardAgent=yes")
250
  if opts:
251
    args.extend(opts)
252
  if node in _MULTIPLEXERS:
253
    spath = _MULTIPLEXERS[node][0]
254
    args.append("-oControlPath=%s" % spath)
255
    args.append("-oControlMaster=no")
256

    
257
  (vcluster_master, vcluster_basedir) = \
258
    qa_config.GetVclusterSettings()
259

    
260
  if vcluster_master:
261
    args.append(vcluster_master)
262
    args.append("%s/%s/cmd" % (vcluster_basedir, node))
263

    
264
    if cmd:
265
      # For virtual clusters the whole command must be wrapped using the "cmd"
266
      # script, as that script sets a number of environment variables. If the
267
      # command contains shell meta characters the whole command needs to be
268
      # quoted.
269
      args.append(utils.ShellQuote(cmd))
270
  else:
271
    args.append(node)
272

    
273
    if cmd:
274
      args.append(cmd)
275

    
276
  return args
277

    
278

    
279
def StartLocalCommand(cmd, _nolog_opts=False, log_cmd=True, **kwargs):
280
  """Starts a local command.
281

282
  """
283
  if log_cmd:
284
    if _nolog_opts:
285
      pcmd = [i for i in cmd if not i.startswith("-")]
286
    else:
287
      pcmd = cmd
288
    print "Command: %s" % utils.ShellQuoteArgs(pcmd)
289
  return subprocess.Popen(cmd, shell=False, **kwargs)
290

    
291

    
292
def StartSSH(node, cmd, strict=True, log_cmd=True):
293
  """Starts SSH.
294

295
  """
296
  return StartLocalCommand(GetSSHCommand(node, cmd, strict=strict),
297
                           _nolog_opts=True, log_cmd=log_cmd)
298

    
299

    
300
def StartMultiplexer(node):
301
  """Starts a multiplexer command.
302

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

305
  """
306
  if node in _MULTIPLEXERS:
307
    return
308

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

    
317

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

321
  """
322
  for node in _MULTIPLEXERS.keys():
323
    (sname, child) = _MULTIPLEXERS.pop(node)
324
    utils.KillProcess(child.pid, timeout=10, waitpid=True)
325
    utils.RemoveFile(sname)
326

    
327

    
328
def GetCommandOutput(node, cmd, tty=None, fail=False):
329
  """Returns the output of a command executed on the given node.
330

331
  @type node: string
332
  @param node: node the command should run on
333
  @type cmd: string
334
  @param cmd: command to be executed in the node (cannot be empty or None)
335
  @type tty: bool or None
336
  @param tty: if we should use tty; if None, it will be auto-detected
337
  @type fail: bool
338
  @param fail: whether the command is expected to fail
339
  """
340
  assert cmd
341
  p = StartLocalCommand(GetSSHCommand(node, cmd, tty=tty),
342
                        stdout=subprocess.PIPE)
343
  rcode = p.wait()
344
  _AssertRetCode(rcode, fail, cmd, node)
345
  return p.stdout.read()
346

    
347

    
348
def GetObjectInfo(infocmd):
349
  """Get and parse information about a Ganeti object.
350

351
  @type infocmd: list of strings
352
  @param infocmd: command to be executed, e.g. ["gnt-cluster", "info"]
353
  @return: the information parsed, appropriately stored in dictionaries,
354
      lists...
355

356
  """
357
  master = qa_config.GetMasterNode()
358
  cmdline = utils.ShellQuoteArgs(infocmd)
359
  info_out = GetCommandOutput(master.primary, cmdline)
360
  return yaml.load(info_out)
361

    
362

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

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

369
  """
370
  # Make sure nobody else has access to it while preserving local permissions
371
  mode = os.stat(src).st_mode & 0700
372

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

    
378
  f = open(src, "r")
379
  try:
380
    p = subprocess.Popen(GetSSHCommand(node, cmd), shell=False, stdin=f,
381
                         stdout=subprocess.PIPE)
382
    AssertEqual(p.wait(), 0)
383

    
384
    # Return temporary filename
385
    return p.stdout.read().strip()
386
  finally:
387
    f.close()
388

    
389

    
390
def UploadData(node, data, mode=0600, filename=None):
391
  """Uploads data to a node and returns the filename.
392

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

396
  """
397
  if filename:
398
    tmp = "tmp=%s" % utils.ShellQuote(filename)
399
  else:
400
    tmp = "tmp=$(tempfile --mode %o --prefix gnt)" % mode
401
  cmd = ("%s && "
402
         "[[ -f \"${tmp}\" ]] && "
403
         "cat > \"${tmp}\" && "
404
         "echo \"${tmp}\"") % tmp
405

    
406
  p = subprocess.Popen(GetSSHCommand(node, cmd), shell=False,
407
                       stdin=subprocess.PIPE, stdout=subprocess.PIPE)
408
  p.stdin.write(data)
409
  p.stdin.close()
410
  AssertEqual(p.wait(), 0)
411

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

    
415

    
416
def BackupFile(node, path):
417
  """Creates a backup of a file on the node and returns the filename.
418

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

422
  """
423
  vpath = MakeNodePath(node, path)
424

    
425
  cmd = ("tmp=$(tempfile --prefix .gnt --directory=$(dirname %s)) && "
426
         "[[ -f \"$tmp\" ]] && "
427
         "cp %s $tmp && "
428
         "echo $tmp") % (utils.ShellQuote(vpath), utils.ShellQuote(vpath))
429

    
430
  # Return temporary filename
431
  result = GetCommandOutput(node, cmd).strip()
432

    
433
  print "Backup filename: %s" % result
434

    
435
  return result
436

    
437

    
438
def ResolveInstanceName(instance):
439
  """Gets the full name of an instance.
440

441
  @type instance: string
442
  @param instance: Instance name
443

444
  """
445
  info = GetObjectInfo(["gnt-instance", "info", instance])
446
  return info[0]["Instance name"]
447

    
448

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

452
  """
453
  info = GetObjectInfo(["gnt-node", "info", node.primary])
454
  return info[0]["Node name"]
455

    
456

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

460
  """
461
  master = qa_config.GetMasterNode()
462
  node_name = ResolveNodeName(node)
463

    
464
  # Get list of all instances
465
  cmd = ["gnt-instance", "list", "--separator=:", "--no-headers",
466
         "--output=name,pnode,snodes"]
467
  output = GetCommandOutput(master.primary, utils.ShellQuoteArgs(cmd))
468

    
469
  instances = []
470
  for line in output.splitlines():
471
    (name, pnode, snodes) = line.split(":", 2)
472
    if ((not secondaries and pnode == node_name) or
473
        (secondaries and node_name in snodes.split(","))):
474
      instances.append(name)
475

    
476
  return instances
477

    
478

    
479
def _SelectQueryFields(rnd, fields):
480
  """Generates a list of fields for query tests.
481

482
  """
483
  # Create copy for shuffling
484
  fields = list(fields)
485
  rnd.shuffle(fields)
486

    
487
  # Check all fields
488
  yield fields
489
  yield sorted(fields)
490

    
491
  # Duplicate fields
492
  yield fields + fields
493

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

    
498

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

502
  """
503
  master = qa_config.GetMasterNode()
504

    
505
  cmd = [listcmd, "list", "--separator=|", "--no-headers",
506
         "--output", ",".join(fields)]
507

    
508
  if names:
509
    cmd.extend(names)
510

    
511
  return GetCommandOutput(master.primary,
512
                          utils.ShellQuoteArgs(cmd)).splitlines()
513

    
514

    
515
def GenericQueryTest(cmd, fields, namefield="name", test_unknown=True):
516
  """Runs a number of tests on query commands.
517

518
  @param cmd: Command name
519
  @param fields: List of field names
520

521
  """
522
  rnd = random.Random(hash(cmd))
523

    
524
  fields = list(fields)
525
  rnd.shuffle(fields)
526

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

    
531
  if namefield is not None:
532
    namelist_fn = compat.partial(_List, cmd, [namefield])
533

    
534
    # When no names were requested, the list must be sorted
535
    names = namelist_fn(None)
536
    AssertEqual(names, utils.NiceSort(names))
537

    
538
    # When requesting specific names, the order must be kept
539
    revnames = list(reversed(names))
540
    AssertEqual(namelist_fn(revnames), revnames)
541

    
542
    randnames = list(names)
543
    rnd.shuffle(randnames)
544
    AssertEqual(namelist_fn(randnames), randnames)
545

    
546
  if test_unknown:
547
    # Listing unknown items must fail
548
    AssertCommand([cmd, "list", "this.name.certainly.does.not.exist"],
549
                  fail=True)
550

    
551
  # Check exit code for listing unknown field
552
  AssertEqual(AssertRedirectedCommand([cmd, "list",
553
                                       "--output=field/does/not/exist"],
554
                                      fail=True),
555
              constants.EXIT_UNKNOWN_FIELD)
556

    
557

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

    
561
  # Listing fields
562
  AssertRedirectedCommand([cmd, "list-fields"])
563
  AssertRedirectedCommand([cmd, "list-fields"] + fields)
564

    
565
  # Check listed fields (all, must be sorted)
566
  realcmd = [cmd, "list-fields", "--separator=|", "--no-headers"]
567
  output = GetCommandOutput(master.primary,
568
                            utils.ShellQuoteArgs(realcmd)).splitlines()
569
  AssertEqual([line.split("|", 1)[0] for line in output],
570
              utils.NiceSort(fields))
571

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

    
577

    
578
def _FormatWithColor(text, seq):
579
  if not seq:
580
    return text
581
  return "%s%s%s" % (seq, text, _RESET_SEQ)
582

    
583

    
584
FormatWarning = lambda text: _FormatWithColor(text, _WARNING_SEQ)
585
FormatError = lambda text: _FormatWithColor(text, _ERROR_SEQ)
586
FormatInfo = lambda text: _FormatWithColor(text, _INFO_SEQ)
587

    
588

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

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

594
  """
595
  master = qa_config.GetMasterNode()
596
  tmp_hosts = UploadData(master.primary, "", mode=0644)
597

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

    
602
  try:
603
    AssertCommand("{ cat %s && echo -e '%s'; } > %s && mv %s %s" %
604
                  (utils.ShellQuote(pathutils.ETC_HOSTS),
605
                   "\\n".join(data),
606
                   utils.ShellQuote(tmp_hosts),
607
                   utils.ShellQuote(tmp_hosts),
608
                   utils.ShellQuote(pathutils.ETC_HOSTS)))
609
  except Exception:
610
    AssertCommand(["rm", "-f", tmp_hosts])
611
    raise
612

    
613

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

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

619
  """
620
  master = qa_config.GetMasterNode()
621
  tmp_hosts = UploadData(master.primary, "", mode=0644)
622
  quoted_tmp_hosts = utils.ShellQuote(tmp_hosts)
623

    
624
  sed_data = " ".join(hostnames)
625
  try:
626
    AssertCommand(("sed -e '/^\(::1\|127\.0\.0\.1\)\s\+%s/d' %s > %s"
627
                   " && mv %s %s") %
628
                   (sed_data, utils.ShellQuote(pathutils.ETC_HOSTS),
629
                    quoted_tmp_hosts, quoted_tmp_hosts,
630
                    utils.ShellQuote(pathutils.ETC_HOSTS)))
631
  except Exception:
632
    AssertCommand(["rm", "-f", tmp_hosts])
633
    raise
634

    
635

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

639
  """
640
  instance_name = _GetName(instance, operator.attrgetter("name"))
641

    
642
  script = qa_config.GetInstanceCheckScript()
643
  if not script:
644
    return
645

    
646
  master_node = qa_config.GetMasterNode()
647

    
648
  # Build command to connect to master node
649
  master_ssh = GetSSHCommand(master_node.primary, "--")
650

    
651
  if running:
652
    running_shellval = "1"
653
    running_text = ""
654
  else:
655
    running_shellval = ""
656
    running_text = "not "
657

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

    
661
  args = [script, instance_name]
662
  env = {
663
    "PATH": constants.HOOKS_PATH,
664
    "RUN_UUID": _RUN_UUID,
665
    "MASTER_SSH": utils.ShellQuoteArgs(master_ssh),
666
    "INSTANCE_NAME": instance_name,
667
    "INSTANCE_RUNNING": running_shellval,
668
    }
669

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

    
674

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

678
  """
679
  if instarg == FIRST_ARG:
680
    instance = args[0]
681
  elif instarg == RETURN_VALUE:
682
    instance = result
683
  else:
684
    raise Exception("Invalid value '%s' for instance argument" % instarg)
685

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

    
691

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

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

702
  """
703
  def decorator(fn):
704
    @functools.wraps(fn)
705
    def wrapper(*args, **kwargs):
706
      _InstanceCheckInner(before, instarg, args, NotImplemented)
707

    
708
      result = fn(*args, **kwargs)
709

    
710
      _InstanceCheckInner(after, instarg, args, result)
711

    
712
      return result
713
    return wrapper
714
  return decorator
715

    
716

    
717
def GetNonexistentGroups(count):
718
  """Gets group names which shouldn't exist on the cluster.
719

720
  @param count: Number of groups to get
721
  @rtype: integer
722

723
  """
724
  return GetNonexistentEntityNames(count, "groups", "group")
725

    
726

    
727
def GetNonexistentEntityNames(count, name_config, name_prefix):
728
  """Gets entity names which shouldn't exist on the cluster.
729

730
  The actualy names can refer to arbitrary entities (for example
731
  groups, networks).
732

733
  @param count: Number of names to get
734
  @rtype: integer
735
  @param name_config: name of the leaf in the config containing
736
    this entity's configuration, including a 'inexistent-'
737
    element
738
  @rtype: string
739
  @param name_prefix: prefix of the entity's names, used to compose
740
    the default values; for example for groups, the prefix is
741
    'group' and the generated names are then group1, group2, ...
742
  @rtype: string
743

744
  """
745
  entities = qa_config.get(name_config, {})
746

    
747
  default = [name_prefix + str(i) for i in range(count)]
748
  assert count <= len(default)
749

    
750
  name_config_inexistent = "inexistent-" + name_config
751
  candidates = entities.get(name_config_inexistent, default)[:count]
752

    
753
  if len(candidates) < count:
754
    raise Exception("At least %s non-existent %s are needed" %
755
                    (count, name_config))
756

    
757
  return candidates
758

    
759

    
760
def MakeNodePath(node, path):
761
  """Builds an absolute path for a virtual node.
762

763
  @type node: string or L{qa_config._QaNode}
764
  @param node: Node
765
  @type path: string
766
  @param path: Path without node-specific prefix
767

768
  """
769
  (_, basedir) = qa_config.GetVclusterSettings()
770

    
771
  if isinstance(node, basestring):
772
    name = node
773
  else:
774
    name = node.primary
775

    
776
  if basedir:
777
    assert path.startswith("/")
778
    return "%s%s" % (vcluster.MakeNodeRoot(basedir, name), path)
779
  else:
780
    return path
781

    
782

    
783
def _GetParameterOptions(specs):
784
  """Helper to build policy options."""
785
  values = ["%s=%s" % (par, val)
786
            for (par, val) in specs.items()]
787
  return ",".join(values)
788

    
789

    
790
def TestSetISpecs(new_specs=None, diff_specs=None, get_policy_fn=None,
791
                  build_cmd_fn=None, fail=False, old_values=None):
792
  """Change instance specs for an object.
793

794
  At most one of new_specs or diff_specs can be specified.
795

796
  @type new_specs: dict
797
  @param new_specs: new complete specs, in the same format returned by
798
      L{ParseIPolicy}.
799
  @type diff_specs: dict
800
  @param diff_specs: diff_specs[key][par], where key is "min", "max", "std". It
801
      can be an incomplete specifications or an empty dictionary.
802
  @type get_policy_fn: function
803
  @param get_policy_fn: function that returns the current policy as in
804
      L{ParseIPolicy}
805
  @type build_cmd_fn: function
806
  @param build_cmd_fn: function that return the full command line from the
807
      options alone
808
  @type fail: bool
809
  @param fail: if the change is expected to fail
810
  @type old_values: tuple
811
  @param old_values: (old_policy, old_specs), as returned by
812
     L{ParseIPolicy}
813
  @return: same as L{ParseIPolicy}
814

815
  """
816
  assert get_policy_fn is not None
817
  assert build_cmd_fn is not None
818
  assert new_specs is None or diff_specs is None
819

    
820
  if old_values:
821
    (old_policy, old_specs) = old_values
822
  else:
823
    (old_policy, old_specs) = get_policy_fn()
824

    
825
  if diff_specs:
826
    new_specs = copy.deepcopy(old_specs)
827
    for (key, parvals) in diff_specs.items():
828
      for (par, val) in parvals.items():
829
        new_specs[key][par] = val
830

    
831
  if new_specs:
832
    cmd = []
833
    if (diff_specs is None or
834
        ("min" in diff_specs or "max" in diff_specs)):
835
      minmax_opt_items = []
836
      for key in ["min", "max"]:
837
        keyopt = _GetParameterOptions(new_specs[key])
838
        minmax_opt_items.append("%s:%s" % (key, keyopt))
839
      cmd.extend([
840
        "--ipolicy-bounds-specs",
841
        "/".join(minmax_opt_items)
842
        ])
843
    if diff_specs:
844
      std_source = diff_specs
845
    else:
846
      std_source = new_specs
847
    std_opt = _GetParameterOptions(std_source.get("std", {}))
848
    if std_opt:
849
      cmd.extend(["--ipolicy-std-specs", std_opt])
850
    AssertCommand(build_cmd_fn(cmd), fail=fail)
851

    
852
    # Check the new state
853
    (eff_policy, eff_specs) = get_policy_fn()
854
    AssertEqual(eff_policy, old_policy)
855
    if fail:
856
      AssertEqual(eff_specs, old_specs)
857
    else:
858
      AssertEqual(eff_specs, new_specs)
859

    
860
  else:
861
    (eff_policy, eff_specs) = (old_policy, old_specs)
862

    
863
  return (eff_policy, eff_specs)
864

    
865

    
866
def ParseIPolicy(policy):
867
  """Parse and split instance an instance policy.
868

869
  @type policy: dict
870
  @param policy: policy, as returned by L{GetObjectInfo}
871
  @rtype: tuple
872
  @return: (policy, specs), where:
873
      - policy is a dictionary of the policy values, instance specs excluded
874
      - specs is dict of dict, specs[key][par] is a spec value, where key is
875
        "min", "max", or "std"
876

877
  """
878
  ret_specs = {}
879
  ret_policy = {}
880
  ispec_keys = constants.ISPECS_MINMAX_KEYS | frozenset([constants.ISPECS_STD])
881
  for (key, val) in policy.items():
882
    if key in ispec_keys:
883
      ret_specs[key] = val
884
    else:
885
      ret_policy[key] = val
886
  return (ret_policy, ret_specs)