qa_utils.py 7 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
24
25
26
# 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
27
import sys
28
29
30
31
32
33
34
35
import subprocess

from ganeti import utils

import qa_config
import qa_error


Michael Hanselmann's avatar
Michael Hanselmann committed
36
37
38
39
40
41
_INFO_SEQ = None
_WARNING_SEQ = None
_ERROR_SEQ = None
_RESET_SEQ = None


42
43
44
45
# List of all hooks
_hooks = []


Michael Hanselmann's avatar
Michael Hanselmann committed
46
47
48
49
50
51
def _SetupColours():
  """Initializes the colour constants.

  """
  global _INFO_SEQ, _WARNING_SEQ, _ERROR_SEQ, _RESET_SEQ

52
53
54
55
  # Don't use colours if stdout isn't a terminal
  if not sys.stdout.isatty():
    return

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


75
def AssertEqual(first, second):
76
77
78
79
  """Raises an error when values aren't equal.

  """
  if not first == second:
80
81
82
83
84
85
86
87
88
    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))
89
90
91
92
93


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

94
95
96
97
98
  Args:
  - node: Node the command should run on
  - cmd: Command to be executed as a list with all parameters
  - strict: Whether to enable strict host key checking

99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
  """
  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.

  """
127
128
129
130
131
132
133
134
135
136
137
138
  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()
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164


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
165
166


167
168
169
170
171
172
173
174
175
176
177
178
179
180
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
181
182
183
def ResolveInstanceName(instance):
  """Gets the full name of an instance.

184
  """
185
  return _ResolveName(['gnt-instance', 'info', instance['name']],
186
187
188
189
190
191
192
193
194
195
196
197
198
199
                      '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
200
201
  """
  master = qa_config.GetMasterNode()
202
  node_name = ResolveNodeName(node)
Michael Hanselmann's avatar
Michael Hanselmann committed
203

204
205
206
207
208
209
210
211
212
213
214
  # 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
215

216
  return instances
Michael Hanselmann's avatar
Michael Hanselmann committed
217
218


219
220
221
222
def _FormatWithColor(text, seq):
  if not seq:
    return text
  return "%s%s%s" % (seq, text, _RESET_SEQ)
Michael Hanselmann's avatar
Michael Hanselmann committed
223
224


225
226
227
FormatWarning = lambda text: _FormatWithColor(text, _WARNING_SEQ)
FormatError = lambda text: _FormatWithColor(text, _ERROR_SEQ)
FormatInfo = lambda text: _FormatWithColor(text, _INFO_SEQ)
228
229
230
231
232
233
234
235
236
237
238
239
240
241


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
242
      print "Loading hook %s" % name
243
244
245
246
      _hooks.append(__import__(name[:-3], None, None, ['']).hook())


class QaHookContext:
247
248
249
  """Definition of context passed to hooks.

  """
250
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
  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(...)

280
  This is based on PEP 318, "Decorators for Functions and Methods".
281

282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
  """
  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