qa_utils.py 6.78 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Copyright (C) 2007 Google Inc.
#
# 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
Michael Hanselmann's avatar
Michael Hanselmann committed
24
import sys
25
26
27
28
29
30
31
32
import subprocess

from ganeti import utils

import qa_config
import qa_error


Michael Hanselmann's avatar
Michael Hanselmann committed
33
34
35
36
37
38
_INFO_SEQ = None
_WARNING_SEQ = None
_ERROR_SEQ = None
_RESET_SEQ = None


39
40
41
42
# List of all hooks
_hooks = []


Michael Hanselmann's avatar
Michael Hanselmann committed
43
44
45
46
47
48
def _SetupColours():
  """Initializes the colour constants.

  """
  global _INFO_SEQ, _WARNING_SEQ, _ERROR_SEQ, _RESET_SEQ

49
50
51
52
  # Don't use colours if stdout isn't a terminal
  if not sys.stdout.isatty():
    return

Michael Hanselmann's avatar
Michael Hanselmann committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
  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()


72
def AssertEqual(first, second):
73
74
75
76
  """Raises an error when values aren't equal.

  """
  if not first == second:
77
78
79
80
81
82
83
84
85
    raise qa_error.Error('%r == %r' % (first, second))


def AssertNotEqual(first, second):
  """Raises an error when values are equal.

  """
  if not first != second:
    raise qa_error.Error('%r != %r' % (first, second))
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118


def GetSSHCommand(node, cmd, strict=True):
  """Builds SSH command to be executed.

  """
  args = [ 'ssh', '-oEscapeChar=none', '-oBatchMode=yes', '-l', 'root' ]

  if strict:
    tmp = 'yes'
  else:
    tmp = 'no'
  args.append('-oStrictHostKeyChecking=%s' % tmp)
  args.append('-oClearAllForwardings=yes')
  args.append('-oForwardAgent=yes')
  args.append(node)

  if qa_config.options.dry_run:
    prefix = 'exit 0; '
  else:
    prefix = ''

  args.append(prefix + cmd)

  print 'SSH:', utils.ShellQuoteArgs(args)

  return args


def StartSSH(node, cmd, strict=True):
  """Starts SSH.

  """
119
120
121
122
123
124
125
126
127
128
129
130
  return subprocess.Popen(GetSSHCommand(node, cmd, strict=strict),
                          shell=False)


def GetCommandOutput(node, cmd):
  """Returns the output of a command executed on the given node.

  """
  p = subprocess.Popen(GetSSHCommand(node, cmd),
                       shell=False, stdout=subprocess.PIPE)
  AssertEqual(p.wait(), 0)
  return p.stdout.read()
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156


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.
  """
  # 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

  f = open(src, 'r')
  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
157
158


159
160
161
162
163
164
165
166
167
168
169
170
171
172
def _ResolveName(cmd, key):
  """Helper function.

  """
  master = qa_config.GetMasterNode()

  output = GetCommandOutput(master['primary'], utils.ShellQuoteArgs(cmd))
  for line in output.splitlines():
    (lkey, lvalue) = line.split(':', 1)
    if lkey == key:
      return lvalue.lstrip()
  raise KeyError("Key not found")


Michael Hanselmann's avatar
Michael Hanselmann committed
173
174
175
def ResolveInstanceName(instance):
  """Gets the full name of an instance.

176
  """
177
  return _ResolveName(['gnt-instance', 'info', instance['name']],
178
179
180
181
182
183
184
185
186
187
188
189
190
191
                      'Instance name')


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

  """
  return _ResolveName(['gnt-node', 'info', node['primary']],
                      'Node name')


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

Michael Hanselmann's avatar
Michael Hanselmann committed
192
193
194
  """
  master = qa_config.GetMasterNode()

195
  node_name = ResolveNodeName(node)
Michael Hanselmann's avatar
Michael Hanselmann committed
196

197
198
199
200
201
202
203
204
205
206
207
  # Get list of all instances
  cmd = ['gnt-instance', 'list', '--separator=:', '--no-headers',
         '--output=name,pnode,snodes']
  output = GetCommandOutput(master['primary'], utils.ShellQuoteArgs(cmd))

  instances = []
  for line in output.splitlines():
    (name, pnode, snodes) = line.split(':', 2)
    if ((not secondaries and pnode == node_name) or
        (secondaries and node_name in snodes.split(','))):
      instances.append(name)
Michael Hanselmann's avatar
Michael Hanselmann committed
208

209
  return instances
Michael Hanselmann's avatar
Michael Hanselmann committed
210
211


212
213
214
215
def _FormatWithColor(text, seq):
  if not seq:
    return text
  return "%s%s%s" % (seq, text, _RESET_SEQ)
Michael Hanselmann's avatar
Michael Hanselmann committed
216
217


218
219
220
FormatWarning = lambda text: _FormatWithColor(text, _WARNING_SEQ)
FormatError = lambda text: _FormatWithColor(text, _ERROR_SEQ)
FormatInfo = lambda text: _FormatWithColor(text, _INFO_SEQ)
221
222
223
224
225
226
227
228
229
230
231
232
233
234


def LoadHooks():
  """Load all QA hooks.

  """
  hooks_dir = qa_config.get('options', {}).get('hooks-dir', None)
  if not hooks_dir:
    return
  if hooks_dir not in sys.path:
    sys.path.insert(0, hooks_dir)
  for name in utils.ListVisibleFiles(hooks_dir):
    if name.endswith('.py'):
      # Load and instanciate hook
Michael Hanselmann's avatar
Michael Hanselmann committed
235
      print "Loading hook %s" % name
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
      _hooks.append(__import__(name[:-3], None, None, ['']).hook())


class QaHookContext:
  name = None
  phase = None
  success = None
  args = None
  kwargs = None


def _CallHooks(ctx):
  """Calls all hooks with the given context.

  """
  if not _hooks:
    return

  name = "%s-%s" % (ctx.phase, ctx.name)
  if ctx.success is not None:
    msg = "%s (success=%s)" % (name, ctx.success)
  else:
    msg = name
  print FormatInfo("Begin %s" % msg)
  for hook in _hooks:
    hook.run(ctx)
  print FormatInfo("End %s" % name)


def DefineHook(name):
  """Wraps a function with calls to hooks.

  Usage: prefix function with @qa_utils.DefineHook(...)

270
271
  This based on PEP 318, "Decorators for Functions and Methods".

272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
  """
  def wrapper(fn):
    def new_f(*args, **kwargs):
      # Create context
      ctx = QaHookContext()
      ctx.name = name
      ctx.phase = 'pre'
      ctx.args = args
      ctx.kwargs = kwargs

      _CallHooks(ctx)
      try:
        ctx.phase = 'post'
        ctx.success = True
        try:
          # Call real function
          return fn(*args, **kwargs)
        except:
          ctx.success = False
          raise
      finally:
        _CallHooks(ctx)

    # Override function metadata
    new_f.func_name = fn.func_name
    new_f.func_doc = fn.func_doc

    return new_f

  return wrapper