ice_validator/tests/structures.py

   1 # -*- coding: utf8 -*-
   2 # ============LICENSE_START====================================================
   3 # org.onap.vvp/validation-scripts
   4 # ===================================================================
   5 # Copyright © 2019 AT&T Intellectual Property. All rights reserved.
   6 # ===================================================================
   7 #
   8 # Unless otherwise specified, all software contained herein is licensed
   9 # under the Apache License, Version 2.0 (the "License");
  10 # you may not use this software except in compliance with the License.
  11 # You may obtain a copy of the License at
  12 #
  13 #             http://www.apache.org/licenses/LICENSE-2.0
  14 #
  15 # Unless required by applicable law or agreed to in writing, software
  16 # distributed under the License is distributed on an "AS IS" BASIS,
  17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18 # See the License for the specific language governing permissions and
  19 # limitations under the License.
  20 #
  21 #
  22 #
  23 # Unless otherwise specified, all documentation contained herein is licensed
  24 # under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  25 # you may not use this documentation except in compliance with the License.
  26 # You may obtain a copy of the License at
  27 #
  28 #             https://creativecommons.org/licenses/by/4.0/
  29 #
  30 # Unless required by applicable law or agreed to in writing, documentation
  31 # distributed under the License is distributed on an "AS IS" BASIS,
  32 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  33 # See the License for the specific language governing permissions and
  34 # limitations under the License.
  35 #
  36 # ============LICENSE_END============================================
  37 #
  38 #
  39 """structures
  40 """
  41 import collections
  42 import inspect
  43 import os
  44 import re
  45 import sys
  46
  47 from tests import cached_yaml as yaml
  48 from tests.helpers import load_yaml
  49 from .utils import nested_dict
  50
  51 VERSION = "4.2.0"
  52
  53 # key = pattern, value = regex compiled from pattern
  54 _REGEX_CACHE = {}
  55
  56
  57 def _get_regex(pattern):
  58     """Return a compiled version of pattern.
  59     Keep result in _REGEX_CACHE to avoid re-compiling.
  60     """
  61     regex = _REGEX_CACHE.get(pattern, None)
  62     if regex is None:
  63         regex = re.compile(pattern)
  64         _REGEX_CACHE[pattern] = regex
  65     return regex
  66
  67
  68 class Hashabledict(dict):
  69     """A hashable dict.
  70     dicts with the same keys and whose keys have the same values
  71     are assigned the same hash.
  72     """
  73
  74     def __hash__(self):
  75         return hash((frozenset(self), frozenset(self.values())))
  76
  77
  78 class HeatProcessor(object):
  79     """base class for xxxx::xxxx::xxxx processors
  80     """
  81
  82     resource_type = None  # string 'xxxx::xxxx::xxxx'
  83     re_rids = collections.OrderedDict()  # OrderedDict of name: regex
  84     # name is a string to name the regex.
  85     # regex parses the proper resource id format.
  86
  87     @staticmethod
  88     def get_param_value(value, withIndex=False):
  89         """Return get_param value of `value`
  90         """
  91         if isinstance(value, dict) and len(value) == 1:
  92             v = value.get("get_param")
  93             if isinstance(v, list) and v:
  94                 if withIndex and len(v) > 1:
  95                     idx = v[1]
  96                     if isinstance(idx, dict):
  97                         idx = idx.get("get_param", idx)
  98                     v = "{}{}".format(v[0], idx)
  99                 else:
 100                     v = v[0]
 101         else:
 102             v = None
 103         return v
 104
 105     @classmethod
 106     def get_resource_or_param_value(cls, value):
 107         """Return the get_resource or get_param value of `value`
 108         """
 109         if isinstance(value, dict) and len(value) == 1:
 110             v = value.get("get_resource") or cls.get_param_value(value)
 111         else:
 112             v = None
 113         return v
 114
 115     @classmethod
 116     def get_rid_match_tuple(cls, rid):
 117         """find the first regex matching `rid` and return the tuple
 118         (name, match object) or ('', None) if no match.
 119         """
 120         rid = "" if rid is None else rid
 121         for name, regex in cls.re_rids.items():
 122             match = regex.match(rid)
 123             if match:
 124                 return name, match
 125         return "", None
 126
 127     @classmethod
 128     def get_rid_patterns(cls):
 129         """Return OrderedDict of name: friendly regex.pattern
 130         "friendly" means the group notation is replaced with
 131         braces, and the trailing "$" is removed.
 132
 133         NOTE
 134         nested parentheses in any rid_pattern will break this parser.
 135         The final character is ASSUMED to be a dollar sign.
 136         """
 137         friendly_pattern = _get_regex(r"\(\?P<(.*?)>.*?\)")
 138         rid_patterns = collections.OrderedDict()
 139         for name, regex in cls.re_rids.items():
 140             rid_patterns[name] = friendly_pattern.sub(
 141                 r"{\1}", regex.pattern  # replace groups with braces
 142             )[
 143                 :-1
 144             ]  # remove trailing $
 145         return rid_patterns
 146
 147     @classmethod
 148     def get_str_replace_name(cls, resource_dict):
 149         """Return the name modified by str_replace of `resource_dict`,
 150         a resource (i.e. a value in some template's resources).
 151         Return None, if there is no name, str_replace, its template,
 152         or any missing parameters.
 153         """
 154         str_replace = Heat.nested_get(
 155             resource_dict, "properties", "name", "str_replace"
 156         )
 157         if not str_replace:
 158             return None
 159         template = Heat.nested_get(str_replace, "template")
 160         if not isinstance(template, str):
 161             return None
 162         params = Heat.nested_get(str_replace, "params", default={})
 163         if not isinstance(params, dict):
 164             return None
 165         # WARNING
 166         # The user must choose non-overlapping keys for params since they
 167         # are replaced in the template in arbitrary order.
 168         name = template
 169         for key, value in params.items():
 170             param = cls.get_param_value(value, withIndex=True)
 171             if param is None:
 172                 return None
 173             name = name.replace(key, str(param))
 174         return name
 175
 176
 177 class CinderVolumeAttachmentProcessor(HeatProcessor):
 178     """ Cinder VolumeAttachment
 179     """
 180
 181     resource_type = "OS::Cinder::VolumeAttachment"
 182
 183     @classmethod
 184     def get_config(cls, resources):
 185         """Return a tuple (va_config, va_count)
 186         va_config - Hashabledict of Cinder Volume Attachment config
 187                     indexed by rid.
 188         va_count - dict of attachment counts indexed by rid.
 189         """
 190         va_count = collections.defaultdict(int)
 191         va_config = Hashabledict()
 192         for resource in resources.values():
 193             resource_type = nested_dict.get(resource, "type")
 194             if resource_type == cls.resource_type:
 195                 config, rids = cls.get_volume_attachment_config(resource)
 196                 for rid in rids:
 197                     va_config[rid] = config
 198                     va_count[rid] += 1
 199         return va_config, va_count
 200
 201     @classmethod
 202     def get_volume_attachment_config(cls, resource):
 203         """Returns the cinder volume attachment configuration
 204         of `resource` as a tuple (config, rids)
 205         where:
 206         - config is a Hashabledict whose keys are the keys of the
 207             properties of resource, and whose values are the
 208             corresponding property values (nova server resource ids)
 209             replaced with the vm-type they reference.
 210         - rids is the set of nova server resource ids referenced by
 211             the property values.
 212         """
 213         config = Hashabledict()
 214         rids = set()
 215         for key, value in (resource.get("properties") or {}).items():
 216             rid = cls.get_resource_or_param_value(value)
 217             if rid:
 218                 name, match = NovaServerProcessor.get_rid_match_tuple(rid)
 219                 if name == "server":
 220                     vm_type = match.groupdict()["vm_type"]
 221                     config[key] = vm_type
 222                     rids.add(rid)
 223         return config, rids
 224
 225
 226 class ContrailV2NetworkFlavorBaseProcessor(HeatProcessor):
 227     """ContrailV2 objects which have network_flavor
 228     """
 229
 230     network_flavor_external = "external"
 231     network_flavor_internal = "internal"
 232     network_flavor_subint = "subinterface"
 233
 234     @classmethod
 235     def get_network_flavor(cls, resource):
 236         """Return the network flavor of resource, one of
 237         "internal" - get_resource, or get_param contains _int_
 238         "subint" - get_param contains _subint_
 239         "external" - otherwise
 240         None - no parameters found to decide the flavor.
 241
 242         resource.properties.virtual_network_refs should be a list.
 243         All the parameters in the list should have the same "flavor"
 244         so the flavor is determined from the first item.
 245         """
 246         network_flavor = None
 247         network_refs = nested_dict.get(resource, "properties", "virtual_network_refs")
 248         if network_refs and isinstance(network_refs, list):
 249             param = network_refs[0]
 250             if isinstance(param, dict):
 251                 if "get_resource" in param:
 252                     network_flavor = cls.network_flavor_internal
 253                 else:
 254                     p = param.get("get_param")
 255                     if isinstance(p, str):
 256                         if "_int_" in p or p.startswith("int_"):
 257                             network_flavor = cls.network_flavor_internal
 258                         elif "_subint_" in p:
 259                             network_flavor = cls.network_flavor_subint
 260                         else:
 261                             network_flavor = cls.network_flavor_external
 262         return network_flavor
 263
 264
 265 class ContrailV2InstanceIpProcessor(ContrailV2NetworkFlavorBaseProcessor):
 266     """ ContrailV2 InstanceIp
 267     """
 268
 269     resource_type = "OS::ContrailV2::InstanceIp"
 270     re_rids = collections.OrderedDict(
 271         [
 272             (
 273                 "internal",
 274                 _get_regex(
 275                     r"(?P<vm_type>.+)"
 276                     r"_(?P<vm_type_index>\d+)"
 277                     r"_int"
 278                     r"_(?P<network_role>.+)"
 279                     r"_vmi"
 280                     r"_(?P<vmi_index>\d+)"
 281                     r"(_v6)?"
 282                     r"_IP"
 283                     r"_(?P<index>\d+)"
 284                     r"$"
 285                 ),
 286             ),
 287             (
 288                 "subinterface",
 289                 _get_regex(
 290                     r"(?P<vm_type>.+)"
 291                     r"_(?P<vm_type_index>\d+)"
 292                     r"_subint"
 293                     r"_(?P<network_role>.+)"
 294                     r"_vmi"
 295                     r"_(?P<vmi_index>\d+)"
 296                     r"(_v6)?"
 297                     r"_IP"
 298                     r"_(?P<index>\d+)"
 299                     r"$"
 300                 ),
 301             ),
 302             (
 303                 "external",
 304                 _get_regex(
 305                     r"(?P<vm_type>.+)"
 306                     r"_(?P<vm_type_index>\d+)"
 307                     r"_(?P<network_role>.+)"
 308                     r"_vmi"
 309                     r"_(?P<vmi_index>\d+)"
 310                     r"(_v6)?"
 311                     r"_IP"
 312                     r"_(?P<index>\d+)"
 313                     r"$"
 314                 ),
 315             ),
 316         ]
 317     )
 318
 319
 320 class ContrailV2InterfaceRouteTableProcessor(HeatProcessor):
 321     """ ContrailV2 InterfaceRouteTable
 322     """
 323
 324     resource_type = "OS::ContrailV2::InterfaceRouteTable"
 325
 326
 327 class ContrailV2NetworkIpamProcessor(HeatProcessor):
 328     """ ContrailV2 NetworkIpam
 329     """
 330
 331     resource_type = "OS::ContrailV2::NetworkIpam"
 332
 333
 334 class ContrailV2PortTupleProcessor(HeatProcessor):
 335     """ ContrailV2 PortTuple
 336     """
 337
 338     resource_type = "OS::ContrailV2::PortTuple"
 339
 340
 341 class ContrailV2ServiceHealthCheckProcessor(HeatProcessor):
 342     """ ContrailV2 ServiceHealthCheck
 343     """
 344
 345     resource_type = "OS::ContrailV2::ServiceHealthCheck"
 346
 347
 348 class ContrailV2ServiceInstanceProcessor(HeatProcessor):
 349     """ ContrailV2 ServiceInstance
 350     """
 351
 352     resource_type = "OS::ContrailV2::ServiceInstance"
 353
 354
 355 class ContrailV2ServiceInstanceIpProcessor(HeatProcessor):
 356     """ ContrailV2 ServiceInstanceIp
 357     """
 358
 359     resource_type = "OS::ContrailV2::ServiceInstanceIp"
 360
 361
 362 class ContrailV2ServiceTemplateProcessor(HeatProcessor):
 363     """ ContrailV2 ServiceTemplate
 364     """
 365
 366     resource_type = "OS::ContrailV2::ServiceTemplate"
 367
 368
 369 class ContrailV2VirtualMachineInterfaceProcessor(ContrailV2NetworkFlavorBaseProcessor):
 370     """ ContrailV2 Virtual Machine Interface resource
 371     """
 372
 373     resource_type = "OS::ContrailV2::VirtualMachineInterface"
 374     re_rids = collections.OrderedDict(
 375         [
 376             (
 377                 "internal",
 378                 _get_regex(
 379                     r"(?P<vm_type>.+)"
 380                     r"_(?P<vm_type_index>\d+)"
 381                     r"_int"
 382                     r"_(?P<network_role>.+)"
 383                     r"_vmi"
 384                     r"_(?P<vmi_index>\d+)"
 385                     r"$"
 386                 ),
 387             ),
 388             (
 389                 "subinterface",
 390                 _get_regex(
 391                     r"(?P<vm_type>.+)"
 392                     r"_(?P<vm_type_index>\d+)"
 393                     r"_subint"
 394                     r"_(?P<network_role>.+)"
 395                     r"_vmi"
 396                     r"_(?P<vmi_index>\d+)"
 397                     r"$"
 398                 ),
 399             ),
 400             (
 401                 "external",
 402                 _get_regex(
 403                     r"(?P<vm_type>.+)"
 404                     r"_(?P<vm_type_index>\d+)"
 405                     r"_(?P<network_role>.+)"
 406                     r"_vmi"
 407                     r"_(?P<vmi_index>\d+)"
 408                     r"$"
 409                 ),
 410             ),
 411         ]
 412     )
 413
 414
 415 class ContrailV2VirtualNetworkProcessor(HeatProcessor):
 416     """ ContrailV2 VirtualNetwork
 417     """
 418
 419     resource_type = "OS::ContrailV2::VirtualNetwork"
 420     re_rids = collections.OrderedDict(
 421         [
 422             ("network", _get_regex(r"int" r"_(?P<network_role>.+)" r"_network" r"$")),
 423             # ("rvn", _get_regex(r"int" r"_(?P<network_role>.+)" r"_RVN" r"$")),
 424         ]
 425     )
 426
 427
 428 class HeatResourceGroupProcessor(HeatProcessor):
 429     """ Heat ResourceGroup
 430     """
 431
 432     resource_type = "OS::Heat::ResourceGroup"
 433     re_rids = collections.OrderedDict(
 434         [
 435             (
 436                 "subint",
 437                 _get_regex(
 438                     r"(?P<vm_type>.+)"
 439                     r"_(?P<vm_type_index>\d+)"
 440                     r"_subint"
 441                     r"_(?P<network_role>.+)"
 442                     r"_port_(?P<port_index>\d+)"
 443                     r"_subinterfaces"
 444                     r"$"
 445                 ),
 446             )
 447         ]
 448     )
 449
 450
 451 class NeutronNetProcessor(HeatProcessor):
 452     """ Neutron Net resource
 453     """
 454
 455     resource_type = "OS::Neutron::Net"
 456     re_rids = collections.OrderedDict(
 457         [("network", _get_regex(r"int" r"_(?P<network_role>.+)" r"_network" r"$"))]
 458     )
 459
 460
 461 class NeutronPortProcessor(HeatProcessor):
 462     """ Neutron Port resource
 463     """
 464
 465     resource_type = "OS::Neutron::Port"
 466     re_rids = collections.OrderedDict(
 467         [
 468             (
 469                 "internal",
 470                 _get_regex(
 471                     r"(?P<vm_type>.+)"
 472                     r"_(?P<vm_type_index>\d+)"
 473                     r"_int"
 474                     r"_(?P<network_role>.+)"
 475                     r"_port_(?P<port_index>\d+)"
 476                     r"$"
 477                 ),
 478             ),
 479             (
 480                 "external",
 481                 _get_regex(
 482                     r"(?P<vm_type>.+)"
 483                     r"_(?P<vm_type_index>\d+)"
 484                     r"_(?P<network_role>.+)"
 485                     r"_port_(?P<port_index>\d+)"
 486                     r"$"
 487                 ),
 488             ),
 489         ]
 490     )
 491
 492     @classmethod
 493     def uses_sr_iov(cls, resource):
 494         """Returns True/False as `resource` is/not
 495         An OS::Nova:Port with the property binding:vnic_type
 496         """
 497         resource_properties = nested_dict.get(resource, "properties", default={})
 498         if nested_dict.get(resource, "type") == cls.resource_type and resource_properties.get("binding:vnic_type", "") == "direct":
 499             return True
 500
 501         return False
 502
 503
 504 class NovaServerProcessor(HeatProcessor):
 505     """ Nova Server resource
 506     """
 507
 508     resource_type = "OS::Nova::Server"
 509     re_rids = collections.OrderedDict(
 510         [
 511             (
 512                 "server",
 513                 _get_regex(r"(?P<vm_type>.+)" r"_server_(?P<vm_type_index>\d+)" r"$"),
 514             )
 515         ]
 516     )
 517
 518     @classmethod
 519     def get_flavor(cls, resource):
 520         """Return the flavor property of `resource`
 521         """
 522         return cls.get_param_value(nested_dict.get(resource, "properties", "flavor"))
 523
 524     @classmethod
 525     def get_image(cls, resource):
 526         """Return the image property of `resource`
 527         """
 528         return cls.get_param_value(nested_dict.get(resource, "properties", "image"))
 529
 530     @classmethod
 531     def get_network(cls, resource):
 532         """Return the network configuration of `resource` as a
 533         frozenset of network-roles.
 534         """
 535         network = set()
 536         networks = nested_dict.get(resource, "properties", "networks")
 537         if isinstance(networks, list):
 538             for port in networks:
 539                 value = cls.get_resource_or_param_value(nested_dict.get(port, "port"))
 540                 name, match = NeutronPortProcessor.get_rid_match_tuple(value)
 541                 if name:
 542                     network_role = match.groupdict().get("network_role")
 543                     if network_role:
 544                         network.add(network_role)
 545         return frozenset(network)
 546
 547     @classmethod
 548     def get_vm_class(cls, resource):
 549         """Return the vm_class of `resource`, a Hashabledict (of
 550         hashable values) whose keys are only the required keys.
 551         Return empty Hashabledict if `resource` is not a NovaServer.
 552         """
 553         vm_class = Hashabledict()
 554         resource_type = nested_dict.get(resource, "type")
 555         if resource_type == cls.resource_type:
 556             d = dict(
 557                 flavor=cls.get_flavor(resource),
 558                 image=cls.get_image(resource),
 559                 networks=cls.get_network(resource),
 560             )
 561             if all(d.values()):
 562                 vm_class.update(d)
 563         return vm_class
 564
 565
 566 class Heat(object):
 567     """A Heat template.
 568     filepath - absolute path to template file.
 569     envpath - absolute path to environmnt file.
 570     """
 571
 572     type_bool = "boolean"
 573     type_boolean = "boolean"
 574     type_cdl = "comma_delimited_list"
 575     type_comma_delimited_list = "comma_delimited_list"
 576     type_json = "json"
 577     type_num = "number"
 578     type_number = "number"
 579     type_str = "string"
 580     type_string = "string"
 581
 582     def __init__(self, filepath=None, envpath=None):
 583         self.filepath = None
 584         self.basename = None
 585         self.dirname = None
 586         self.yml = None
 587         self.heat_template_version = None
 588         self.description = None
 589         self.parameter_groups = None
 590         self.parameters = None
 591         self.resources = None
 592         self.outputs = None
 593         self.conditions = None
 594         if filepath:
 595             self.load(filepath)
 596         self.env = None
 597         if envpath:
 598             self.load_env(envpath)
 599         self.heat_processors = self.get_heat_processors()
 600
 601     @property
 602     def contrail_resources(self):
 603         """This attribute is a dict of Contrail resources.
 604         """
 605         return self.get_resource_by_type(
 606             resource_type=ContrailV2VirtualMachineInterfaceProcessor.resource_type
 607         )
 608
 609     def get_all_resources(self, base_dir):
 610         """
 611         Like ``resources``,
 612         but this returns all the resources definitions
 613         defined in the template, resource groups, and nested YAML files.
 614         """
 615         resources = {}
 616         for r_id, r_data in self.resources.items():
 617             resources[r_id] = r_data
 618             resource = Resource(r_id, r_data)
 619             if resource.is_nested():
 620                 nested = Heat(os.path.join(base_dir, resource.get_nested_filename()))
 621                 resources.update(nested.get_all_resources(base_dir))
 622         return resources
 623
 624     @staticmethod
 625     def get_heat_processors():
 626         """Return a dict, key is resource_type, value is the
 627         HeatProcessor subclass whose resource_type is the key.
 628         """
 629         return _HEAT_PROCESSORS
 630
 631     def get_resource_by_type(self, resource_type):
 632         """Return dict of resources whose type is `resource_type`.
 633         key is resource_id, value is resource.
 634         """
 635         return {
 636             rid: resource
 637             for rid, resource in self.resources.items()
 638             if self.nested_get(resource, "type") == resource_type
 639         }
 640
 641     def get_rid_match_tuple(self, rid, resource_type):
 642         """return get_rid_match_tuple(rid) called on the class
 643         corresponding to the given resource_type.
 644         """
 645         processor = self.heat_processors.get(resource_type, HeatProcessor)
 646         return processor.get_rid_match_tuple(rid)
 647
 648     def get_vm_type(self, rid, resource=None):
 649         """return the vm_type
 650         """
 651         if resource is None:
 652             resource = self
 653         resource_type = self.nested_get(resource, "type")
 654         match = self.get_rid_match_tuple(rid, resource_type)[1]
 655         vm_type = match.groupdict().get("vm_type") if match else None
 656         return vm_type
 657
 658     def load(self, filepath):
 659         """Load the Heat template given a filepath.
 660         """
 661         self.filepath = filepath
 662         self.basename = os.path.basename(self.filepath)
 663         self.dirname = os.path.dirname(self.filepath)
 664         with open(self.filepath) as fi:
 665             self.yml = yaml.load(fi)
 666         self.heat_template_version = self.yml.get("heat_template_version", None)
 667         self.description = self.yml.get("description", "")
 668         self.parameter_groups = self.yml.get("parameter_groups") or {}
 669         self.parameters = self.yml.get("parameters") or {}
 670         self.resources = self.yml.get("resources") or {}
 671         self.outputs = self.yml.get("outputs") or {}
 672         self.conditions = self.yml.get("conditions") or {}
 673
 674     def load_env(self, envpath):
 675         """Load the Environment template given a envpath.
 676         """
 677         self.env = Env(filepath=envpath)
 678
 679     @staticmethod
 680     def nested_get(dic, *keys, **kwargs):
 681         """make utils.nested_dict.get available as a class method.
 682         """
 683         return nested_dict.get(dic, *keys, **kwargs)
 684
 685     @property
 686     def neutron_port_resources(self):
 687         """This attribute is a dict of Neutron Ports
 688         """
 689         return self.get_resource_by_type(
 690             resource_type=NeutronPortProcessor.resource_type
 691         )
 692
 693     @property
 694     def nova_server_resources(self):
 695         """This attribute is a dict of Nova Servers
 696         """
 697         return self.get_resource_by_type(
 698             resource_type=NovaServerProcessor.resource_type
 699         )
 700
 701     @staticmethod
 702     def part_is_in_name(part, name):
 703         """
 704         Return True if any of
 705         - name starts with part + '_'
 706         - name contains '_' + part + '_'
 707         - name ends with '_' + part
 708         False otherwise
 709         """
 710         return bool(
 711             re.search("(^(%(x)s)_)|(_(%(x)s)_)|(_(%(x)s)$)" % dict(x=part), name)
 712         )
 713
 714
 715 class Env(Heat):
 716     """An Environment file
 717     """
 718
 719     pass
 720
 721
 722 class Resource(object):
 723     """A Resource
 724     """
 725
 726     def __init__(self, resource_id=None, resource=None):
 727         self.resource_id = resource_id or ""
 728         self.resource = resource or {}
 729         self.properties = self.resource.get("properties", {})
 730         self.resource_type = self.resource.get("type", "")
 731
 732     @staticmethod
 733     def get_index_var(resource):
 734         """Return the index_var for this resource.
 735         """
 736         index_var = nested_dict.get(resource, "properties", "index_var") or "index"
 737         return index_var
 738
 739     def get_nested_filename(self):
 740         """Returns the filename of the nested YAML file if the
 741         resource is a nested YAML or ResourceDef, returns '' otherwise."""
 742         typ = self.resource.get("type", "")
 743         if typ == "OS::Heat::ResourceGroup":
 744             rd = nested_dict.get(self.resource, "properties", "resource_def")
 745             typ = rd.get("type", "") if rd else ""
 746         ext = os.path.splitext(typ)[1]
 747         ext = ext.lower()
 748         if ext == ".yml" or ext == ".yaml":
 749             return typ
 750         else:
 751             return ""
 752
 753     def get_nested_properties(self):
 754         """
 755         Returns {} if not nested
 756         Returns resource: properties if nested
 757         Returns resource: properties: resource_def: properties if RG
 758         """
 759         if not bool(self.get_nested_filename()):
 760             return {}
 761         elif self.resource_type == "OS::Heat::ResourceGroup":
 762             return nested_dict.get(
 763                 self.properties, "resource_def", "properties", default={}
 764             )
 765         else:
 766             return self.properties
 767
 768     @property
 769     def depends_on(self):
 770         """
 771         Returns the list of resources this resource depends on.  Always
 772         returns a list.
 773
 774         :return: list of all resource IDs this resource depends on.  If none,
 775                  then returns an empty list
 776         """
 777         parents = self.resource.get("depends_on", [])
 778         return parents if isinstance(parents, list) else [parents]
 779
 780     def is_nested(self):
 781         """Returns True if the resource represents a Nested YAML resource
 782         using either type: {filename} or ResourceGroup -> resource_def"""
 783         return bool(self.get_nested_filename())
 784
 785     def get_nested_yaml(self, base_dir):
 786         """If the resource represents a Nested YAML resource, then it
 787         returns the loaded YAML.  If the resource is not nested or the
 788         file cannot be found, then an empty dict is returned"""
 789         filename = self.get_nested_filename()
 790         if filename:
 791             file_path = os.path.join(base_dir, filename)
 792             return load_yaml(file_path) if os.path.exists(file_path) else {}
 793         else:
 794             return {}
 795
 796
 797 def get_all_resources(yaml_files):
 798     """Return a dict, resource id: resource
 799     of the union of resources across all files.
 800     """
 801     resources = {}
 802     for heat_template in yaml_files:
 803         heat = Heat(filepath=heat_template)
 804         dirname = os.path.dirname(heat_template)
 805         resources.update(heat.get_all_resources(dirname))
 806     return resources
 807
 808
 809 def _get_heat_processors():
 810     """Introspect this module and return a
 811     dict of all HeatProcessor sub-classes with a (True) resource_type.
 812     Key is the resource_type, value is the corrresponding class.
 813     """
 814     mod_classes = inspect.getmembers(sys.modules[__name__], inspect.isclass)
 815     heat_processors = {
 816         c.resource_type: c
 817         for _, c in mod_classes
 818         if issubclass(c, HeatProcessor) and c.resource_type
 819     }
 820     return heat_processors
 821
 822
 823 _HEAT_PROCESSORS = _get_heat_processors()