yardstick/common/ansible_common.py

   1 # Copyright (c) 2016-2017 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 from __future__ import absolute_import
  16
  17 import cgitb
  18 import collections
  19 import contextlib as cl
  20 import json
  21 import logging
  22 import os
  23 from collections import Mapping, MutableMapping, Iterable, Callable, deque
  24 from functools import partial
  25 from itertools import chain
  26 from subprocess import CalledProcessError, Popen, PIPE
  27 from tempfile import NamedTemporaryFile
  28
  29 import six
  30 import six.moves.configparser as ConfigParser
  31 import yaml
  32 from six import StringIO
  33 from chainmap import ChainMap
  34 from oslo_serialization import jsonutils
  35
  36 from yardstick.common.utils import Timer
  37 from yardstick.common import constants as consts
  38
  39 cgitb.enable(format="text")
  40
  41 _LOCAL_DEFAULT = object()
  42
  43 LOG = logging.getLogger(__name__)
  44
  45
  46 def overwrite_dict_to_cfg(cfg, cfg_dict):
  47     for section in cfg_dict:
  48         # delete then add
  49         cfg.remove_section(section)
  50         cfg.add_section(section)
  51     for section, val in cfg_dict.items():
  52         if isinstance(val, six.string_types):
  53             cfg.set(section, val)
  54         elif isinstance(val, collections.Mapping):
  55             for k, v in val.items():
  56                 cfg.set(section, k, v)
  57         else:
  58             for v in val:
  59                 cfg.set(section, v)
  60
  61
  62 class TempfileContext(object):
  63     @staticmethod
  64     def _try_get_filename_from_file(param):
  65         try:
  66             if isinstance(param.read, Callable):
  67                 return param.name
  68         except AttributeError:
  69             pass
  70         # return what was given
  71         return param
  72
  73     def __init__(self, data, write_func, descriptor, data_types, directory,
  74                  prefix, suffix, creator):
  75         super(TempfileContext, self).__init__()
  76         self.data = data
  77         self.write_func = write_func
  78         self.descriptor = descriptor
  79         self.data_types = data_types
  80         self.directory = directory
  81         self.suffix = suffix
  82         self.creator = creator
  83         self.data_file = None
  84         self.prefix = prefix
  85
  86     def __enter__(self):
  87         self.data = self._try_get_filename_from_file(self.data)
  88         if isinstance(self.data, six.string_types):
  89             # string -> playbook filename directly
  90             data_filename = self.data
  91         elif isinstance(self.data, self.data_types):
  92             # list of playbooks -> put into a temporary playbook file
  93             if self.prefix:
  94                 self.prefix = self.prefix.rstrip('_')
  95             data_filename = ''.join([self.prefix, self.suffix])
  96             if self.directory:
  97                 data_filename = os.path.join(self.directory, data_filename)
  98             if not os.path.exists(data_filename):
  99                 self.data_file = open(data_filename, 'w+')
 100             else:
 101                 self.data_file = self.creator()
 102             self.write_func(self.data_file)
 103             self.data_file.flush()
 104             self.data_file.seek(0)
 105         else:
 106             # data not passed properly -> error
 107             LOG.error("%s type not recognized: %s", self.descriptor, self.data)
 108             raise ValueError("{} type not recognized".format(self.descriptor))
 109
 110         LOG.debug("%s file : %s", self.descriptor, data_filename)
 111
 112         return data_filename
 113
 114     def __exit__(self, exc_type, exc_val, exc_tb):
 115         if self.data_file:
 116             self.data_file.close()
 117
 118
 119 class CustomTemporaryFile(object):
 120     DEFAULT_SUFFIX = None
 121     DEFAULT_DATA_TYPES = None
 122
 123     def __init__(self, directory, prefix, suffix=_LOCAL_DEFAULT,
 124                  data_types=_LOCAL_DEFAULT):
 125         super(CustomTemporaryFile, self).__init__()
 126         self.directory = directory
 127         self.prefix = prefix
 128         if suffix is not _LOCAL_DEFAULT:
 129             self.suffix = suffix
 130         else:
 131             self.suffix = self.DEFAULT_SUFFIX
 132         if data_types is not _LOCAL_DEFAULT:
 133             self.data_types = data_types
 134         else:
 135             self.data_types = self.DEFAULT_DATA_TYPES
 136         # must open "w+" so unicode is encoded correctly
 137         self.creator = partial(NamedTemporaryFile, mode="w+", delete=False,
 138                                dir=directory,
 139                                prefix=prefix,
 140                                suffix=self.suffix)
 141
 142     def make_context(self, data, write_func, descriptor='data'):
 143         return TempfileContext(data, write_func, descriptor, self.data_types,
 144                                self.directory, self.prefix, self.suffix,
 145                                self.creator)
 146
 147
 148 class ListTemporaryFile(CustomTemporaryFile):
 149     DEFAULT_DATA_TYPES = (list, tuple)
 150
 151
 152 class MapTemporaryFile(CustomTemporaryFile):
 153     DEFAULT_DATA_TYPES = dict
 154
 155
 156 class YmlTemporaryFile(ListTemporaryFile):
 157     DEFAULT_SUFFIX = '.yml'
 158
 159
 160 class IniListTemporaryFile(ListTemporaryFile):
 161     DEFAULT_SUFFIX = '.ini'
 162
 163
 164 class IniMapTemporaryFile(MapTemporaryFile):
 165     DEFAULT_SUFFIX = '.ini'
 166
 167
 168 class JsonTemporaryFile(MapTemporaryFile):
 169     DEFAULT_SUFFIX = '.json'
 170
 171
 172 class FileNameGenerator(object):
 173     @staticmethod
 174     def get_generator_from_filename(filename, directory, prefix, middle):
 175         basename = os.path.splitext(os.path.basename(filename))[0]
 176         if not basename.startswith(prefix):
 177             part_list = [prefix, middle, basename]
 178         elif not middle or middle in basename:
 179             part_list = [basename]
 180         else:
 181             part_list = [middle, basename]
 182         return FileNameGenerator(directory=directory, part_list=part_list)
 183
 184     @staticmethod
 185     def _handle_existing_file(filename):
 186         if not os.path.exists(filename):
 187             return filename
 188
 189         prefix, suffix = os.path.splitext(os.path.basename(filename))
 190         directory = os.path.dirname(filename)
 191         if not prefix.endswith('_'):
 192             prefix += '_'
 193
 194         temp_file = NamedTemporaryFile(delete=False, dir=directory,
 195                                        prefix=prefix, suffix=suffix)
 196         with cl.closing(temp_file):
 197             return temp_file.name
 198
 199     def __init__(self, directory, part_list):
 200         super(FileNameGenerator, self).__init__()
 201         self.directory = directory
 202         self.part_list = part_list
 203
 204     def make(self, extra):
 205         if not isinstance(extra, Iterable) or isinstance(extra,
 206                                                          six.string_types):
 207             extra = (extra,)  # wrap the singleton in an iterable
 208         return self._handle_existing_file(
 209             os.path.join(
 210                 self.directory,
 211                 '_'.join(chain(self.part_list, extra))
 212             )
 213         )
 214
 215
 216 class AnsibleNodeDict(Mapping):
 217     def __init__(self, node_class, nodes):
 218         super(AnsibleNodeDict, self).__init__()
 219         # create a dict of name, Node instance
 220         self.node_dict = {k: v for k, v in
 221                           (node_class(node).get_tuple() for node in
 222                            nodes)}
 223         # collect all the node roles
 224         self.node_roles = set(
 225             n['role'] for n in six.itervalues(self.node_dict))
 226
 227     def __repr__(self):
 228         return repr(self.node_dict)
 229
 230     def __len__(self):
 231         return len(self.node_dict)
 232
 233     def __getitem__(self, item):
 234         return self.node_dict[item]
 235
 236     def __iter__(self):
 237         return iter(self.node_dict)
 238
 239     def iter_all_of_type(self, node_type, default=_LOCAL_DEFAULT):
 240         return (node for node in six.itervalues(self) if
 241                 node.is_role(node_type, default))
 242
 243     def gen_inventory_lines_for_all_of_type(self, node_type,
 244                                             default=_LOCAL_DEFAULT):
 245         return [node.gen_inventory_line() for node in
 246                 self.iter_all_of_type(node_type, default)]
 247
 248     def gen_all_inventory_lines(self):
 249         return [node.gen_inventory_line() for node in
 250                 six.itervalues(self.node_dict)]
 251
 252     def gen_inventory_groups(self):
 253         # lowercase group names
 254         return {role.lower(): [node['name'] for
 255                                node in self.iter_all_of_type(role)]
 256                 for role in self.node_roles}
 257
 258
 259 class AnsibleNode(MutableMapping):
 260     ANSIBLE_NODE_KEY_MAP = {
 261         u'ansible_host': 'ip',
 262         u'ansible_user': 'user',
 263         u'ansible_port': 'ssh_port',
 264         u'ansible_ssh_pass': 'password',
 265         u'ansible_ssh_private_key_file': 'key_filename',
 266     }
 267
 268     def __init__(self, data=None, **kwargs):
 269         super(AnsibleNode, self).__init__()
 270         if isinstance(data, MutableMapping):
 271             self.data = data
 272         else:
 273             self.data = kwargs
 274
 275     def __repr__(self):
 276         return 'AnsibleNode<{}>'.format(self.data)
 277
 278     def __len__(self):
 279         return len(self.data)
 280
 281     def __iter__(self):
 282         return iter(self.data)
 283
 284     @property
 285     def node_key_map(self):
 286         return self.ANSIBLE_NODE_KEY_MAP
 287
 288     def get_inventory_params(self):
 289         node_key_map = self.node_key_map
 290         # password or key_filename may not be present
 291         return {inventory_key: self[self_key] for inventory_key, self_key in
 292                 node_key_map.items() if self_key in self}
 293
 294     def is_role(self, node_type, default=_LOCAL_DEFAULT):
 295         if default is not _LOCAL_DEFAULT:
 296             return self.setdefault('role', default) in node_type
 297         return node_type in self.get('role', set())
 298
 299     def gen_inventory_line(self):
 300         inventory_params = self.get_inventory_params()
 301         # use format to convert ints
 302         # sort to ensure consistent key value ordering
 303         formatted_args = (u"{}={}".format(*entry) for entry in
 304                           sorted(inventory_params.items()))
 305         line = u" ".join(chain([self['name']], formatted_args))
 306         return line
 307
 308     def get_tuple(self):
 309         return self['name'], self
 310
 311     def __contains__(self, key):
 312         return self.data.__contains__(key)
 313
 314     def __getitem__(self, item):
 315         return self.data[item]
 316
 317     def __setitem__(self, key, value):
 318         self.data[key] = value
 319
 320     def __delitem__(self, key):
 321         del self.data[key]
 322
 323     def __getattr__(self, item):
 324         return getattr(self.data, item)
 325
 326
 327 class AnsibleCommon(object):
 328     NODE_CLASS = AnsibleNode
 329     OUTFILE_PREFIX_TEMPLATE = 'ansible_{:02}'
 330
 331     __DEFAULT_VALUES_MAP = {
 332         'default_timeout': 1200,
 333         'counter': 0,
 334         'prefix': '',
 335         # default 10 min ansible timeout for non-main calls
 336         'ansible_timeout': 600,
 337         'scripts_dest': None,
 338         '_deploy_dir': _LOCAL_DEFAULT,
 339     }
 340
 341     __DEFAULT_CALLABLES_MAP = {
 342         'test_vars': dict,
 343         'inventory_dict': dict,
 344         '_node_dict': dict,
 345         '_node_info_dict': dict,
 346     }
 347
 348     @classmethod
 349     def _get_defaults(cls):
 350         # subclasses will override to change defaults using the ChainMap
 351         # layering
 352         values_map_deque, defaults_map_deque = cls._get_defaults_map_deques()
 353         return ChainMap(*values_map_deque), ChainMap(*defaults_map_deque)
 354
 355     @classmethod
 356     def _get_defaults_map_deques(cls):
 357         # deque so we can insert or append easily
 358         return (deque([cls.__DEFAULT_VALUES_MAP]),
 359                 deque([cls.__DEFAULT_CALLABLES_MAP]))
 360
 361     def __init__(self, nodes, **kwargs):
 362         # TODO: add default Heat vars
 363         super(AnsibleCommon, self).__init__()
 364         self.nodes = nodes
 365         self.counter = 0
 366         self.prefix = ''
 367         # default 10 min ansible timeout for non-main calls
 368         self.ansible_timeout = 600
 369         self.inventory_dict = None
 370         self.scripts_dest = None
 371         self._deploy_dir = _LOCAL_DEFAULT
 372         self._node_dict = None
 373         self._node_info_dict = None
 374         self.callable_task = None
 375         self.test_vars = None
 376         self.default_timeout = None
 377         self.reset(**kwargs)
 378
 379     def reset(self, **kwargs):
 380         """
 381         reset all attributes based on various layers of default dicts
 382         including new default added in subclasses
 383         """
 384
 385         default_values_map, default_callables_map = self._get_defaults()
 386         for name, default_value in list(default_values_map.items()):
 387             setattr(self, name, kwargs.pop(name, default_value))
 388
 389         for name, func in list(default_callables_map.items()):
 390             try:
 391                 value = kwargs.pop(name)
 392             except KeyError:
 393                 # usually dict()
 394                 value = func()
 395             setattr(self, name, value)
 396
 397     def do_install(self, playbook, directory):
 398         # TODO: how to get openstack nodes from Heat
 399         self.gen_inventory_ini_dict()
 400         self.execute_ansible(playbook, directory)
 401
 402     @property
 403     def deploy_dir(self):
 404         if self._deploy_dir is _LOCAL_DEFAULT:
 405             raise ValueError('Deploy dir must be set before using it')
 406         return self._deploy_dir
 407
 408     @deploy_dir.setter
 409     def deploy_dir(self, value):
 410         self._deploy_dir = value
 411
 412     @property
 413     def node_dict(self):
 414         if not self._node_dict:
 415             self._node_dict = AnsibleNodeDict(self.NODE_CLASS, self.nodes)
 416             LOG.debug("node_dict = \n%s", self._node_dict)
 417         return self._node_dict
 418
 419     def gen_inventory_ini_dict(self):
 420         if self.inventory_dict and isinstance(self.inventory_dict,
 421                                               MutableMapping):
 422             return
 423
 424         node_dict = self.node_dict
 425         # add all nodes to 'node' group and specify full parameter there
 426         self.inventory_dict = {
 427             "nodes": node_dict.gen_all_inventory_lines()
 428         }
 429         # place nodes into ansible groups according to their role
 430         # using just node name
 431         self.inventory_dict.update(node_dict.gen_inventory_groups())
 432
 433     @staticmethod
 434     def ansible_env(directory, log_file):
 435         # have to overload here in the env because we can't modify local.conf
 436         ansible_dict = dict(os.environ, **{
 437             "ANSIBLE_LOG_PATH": os.path.join(directory, log_file),
 438             "ANSIBLE_LOG_BASE": directory,
 439             "ANSIBLE_ROLES_PATH": consts.ANSIBLE_ROLES_PATH,
 440             # # required for SSH to work
 441             # "ANSIBLE_SSH_ARGS": "-o UserKnownHostsFile=/dev/null "
 442             #                     "-o GSSAPIAuthentication=no "
 443             #                     "-o PreferredAuthentications=password "
 444             #                     "-o ControlMaster=auto "
 445             #                     "-o ControlPersist=60s",
 446             # "ANSIBLE_HOST_KEY_CHECKING": "False",
 447             # "ANSIBLE_SSH_PIPELINING": "True",
 448         })
 449         return ansible_dict
 450
 451     def _gen_ansible_playbook_file(self, playbooks, directory, prefix='tmp'):
 452         # check what is passed in playbooks
 453         if isinstance(playbooks, (list, tuple)):
 454             if len(playbooks) == 1:
 455                 # list or tuple with one member -> take it
 456                 playbooks = playbooks[0]
 457             else:
 458                 playbooks = [{'include': playbook} for playbook in playbooks]
 459         prefix = '_'.join([self.prefix, prefix, 'playbook'])
 460         yml_temp_file = YmlTemporaryFile(directory=directory, prefix=prefix)
 461         write_func = partial(yaml.safe_dump, playbooks,
 462                              default_flow_style=False,
 463                              explicit_start=True)
 464         return yml_temp_file.make_context(playbooks, write_func,
 465                                           descriptor='playbooks')
 466
 467     def _gen_ansible_inventory_file(self, directory, prefix='tmp'):
 468         def write_func(data_file):
 469             overwrite_dict_to_cfg(inventory_config, self.inventory_dict)
 470             debug_inventory = StringIO()
 471             inventory_config.write(debug_inventory)
 472             LOG.debug("inventory = \n%s", debug_inventory.getvalue())
 473             inventory_config.write(data_file)
 474
 475         prefix = '_'.join([self.prefix, prefix, 'inventory'])
 476         ini_temp_file = IniMapTemporaryFile(directory=directory, prefix=prefix)
 477         inventory_config = ConfigParser.ConfigParser(allow_no_value=True)
 478         # disable default lowercasing
 479         inventory_config.optionxform = str
 480         return ini_temp_file.make_context(self.inventory_dict, write_func,
 481                                           descriptor='inventory')
 482
 483     def _gen_ansible_extra_vars(self, extra_vars, directory, prefix='tmp'):
 484         if not isinstance(extra_vars, MutableMapping):
 485             extra_vars = self.test_vars
 486         prefix = '_'.join([self.prefix, prefix, 'extra_vars'])
 487         # use JSON because Python YAML serializes unicode wierdly
 488         json_temp_file = JsonTemporaryFile(directory=directory, prefix=prefix)
 489         write_func = partial(json.dump, extra_vars, indent=4)
 490         return json_temp_file.make_context(extra_vars, write_func,
 491                                            descriptor='extra_vars')
 492
 493     def _gen_log_names(self, directory, prefix, playbook_filename):
 494         generator = FileNameGenerator.get_generator_from_filename(
 495             playbook_filename, directory, self.prefix, prefix)
 496         return generator.make('execute.log'), generator.make(
 497             'syntax_check.log')
 498
 499     @staticmethod
 500     def get_timeout(*timeouts):
 501         for timeout in timeouts:
 502             try:
 503                 timeout = float(timeout)
 504                 if timeout > 0:
 505                     break
 506             except (TypeError, ValueError):
 507                 pass
 508         else:
 509             timeout = 1200.0
 510         return timeout
 511
 512     def _generate_ansible_cfg(self, directory):
 513         parser = ConfigParser.ConfigParser()
 514         parser.add_section('defaults')
 515         parser.set('defaults', 'host_key_checking', 'False')
 516
 517         cfg_path = os.path.join(directory, 'ansible.cfg')
 518         with open(cfg_path, 'w') as f:
 519             parser.write(f)
 520
 521     def get_sut_info(self, directory, sut_dir='sut'):
 522         if not os.path.isdir(directory):
 523             raise OSError('No such directory: %s' % directory)
 524
 525         self._generate_ansible_cfg(directory)
 526
 527         prefix = 'tmp'
 528         self.gen_inventory_ini_dict()
 529         ini_file = self._gen_ansible_inventory_file(directory, prefix=prefix)
 530         with ini_file as f:
 531             inventory_path = str(f)
 532
 533         self._exec_get_sut_info_cmd(directory, inventory_path, sut_dir)
 534
 535         sut_dir = os.path.join(directory, sut_dir)
 536         sut_info = self._gen_sut_info_dict(sut_dir)
 537
 538         return sut_info
 539
 540     def _exec_get_sut_info_cmd(self, directory, inventory_path, sut_dir):
 541         cmd = ['ansible', 'all', '-m', 'setup', '-i',
 542                inventory_path, '--tree', sut_dir]
 543
 544         proc = Popen(cmd, stdout=PIPE, cwd=directory)
 545         output, _ = proc.communicate()
 546         retcode = proc.wait()
 547         LOG.debug("exit status = %s", retcode)
 548         if retcode != 0:
 549             raise CalledProcessError(retcode, cmd, output)
 550
 551     def _gen_sut_info_dict(self, sut_dir):
 552         sut_info = {}
 553
 554         if os.path.isdir(sut_dir):
 555             root, _, files = next(os.walk(sut_dir))
 556             for filename in files:
 557                 abs_path = os.path.join(root, filename)
 558                 with open(abs_path) as f:
 559                     data = jsonutils.load(f)
 560                 sut_info[filename] = data
 561
 562         return sut_info
 563
 564     def execute_ansible(self, playbooks, directory, timeout=None,
 565                         extra_vars=None, ansible_check=False, prefix='tmp',
 566                         verbose=False):
 567         # there can be three types of dirs:
 568         #  log dir: can be anywhere
 569         #  inventory dir: can be anywhere
 570         #  playbook dir: use include to point to files in  consts.ANSIBLE_DIR
 571
 572         if not os.path.isdir(directory):
 573             raise OSError("Not a directory, %s" % directory)
 574         timeout = self.get_timeout(timeout, self.default_timeout)
 575
 576         self.counter += 1
 577         self.prefix = self.OUTFILE_PREFIX_TEMPLATE.format(self.counter)
 578
 579         playbook_ctx = self._gen_ansible_playbook_file(playbooks, directory,
 580                                                        prefix)
 581         inventory_ctx = self._gen_ansible_inventory_file(directory,
 582                                                          prefix=prefix)
 583         extra_vars_ctx = self._gen_ansible_extra_vars(extra_vars, directory,
 584                                                       prefix=prefix)
 585
 586         with playbook_ctx as playbook_filename, \
 587                 inventory_ctx as inventory_filename, \
 588                 extra_vars_ctx as extra_vars_filename:
 589             cmd = [
 590                 "ansible-playbook",
 591                 "--syntax-check",
 592                 "-i",
 593                 inventory_filename,
 594             ]
 595             if verbose:
 596                 cmd.append('-vvv')
 597             if extra_vars_filename is not None:
 598                 cmd.extend([
 599                     "-e",
 600                     "@{}".format(extra_vars_filename),
 601                 ])
 602             cmd.append(playbook_filename)
 603
 604             log_file_main, log_file_checks = self._gen_log_names(
 605                 directory, prefix, playbook_filename)
 606
 607             exec_args = {
 608                 'cwd': directory,
 609                 'shell': False,
 610             }
 611
 612             if ansible_check:
 613                 LOG.debug('log file checks: %s', log_file_checks)
 614                 exec_args.update({
 615                     'env': self.ansible_env(directory, log_file_checks),
 616                     # TODO: add timeout support of use subprocess32 backport
 617                     # 'timeout': timeout / 2,
 618                 })
 619                 with Timer() as timer:
 620                     proc = Popen(cmd, stdout=PIPE, **exec_args)
 621                     output, _ = proc.communicate()
 622                     retcode = proc.wait()
 623                 LOG.debug("exit status = %s", retcode)
 624                 if retcode != 0:
 625                     raise CalledProcessError(retcode, cmd, output)
 626                 timeout -= timer.total_seconds()
 627
 628             cmd.remove("--syntax-check")
 629             LOG.debug('log file main: %s', log_file_main)
 630             exec_args.update({
 631                 'env': self.ansible_env(directory, log_file_main),
 632                 # TODO: add timeout support of use subprocess32 backport
 633                 # 'timeout': timeout,
 634             })
 635             proc = Popen(cmd, stdout=PIPE, **exec_args)
 636             output, _ = proc.communicate()
 637             retcode = proc.wait()
 638             LOG.debug("exit status = %s", retcode)
 639             if retcode != 0:
 640                 raise CalledProcessError(retcode, cmd, output)
 641             return output