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, get_param
  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=None, count=1):
 610         """
 611         Like ``resources``, but this returns all the resources definitions
 612         defined in the template, resource groups, and nested YAML files.
 613
 614         A special variable will be added to all resource properties (__count__).
 615         This will normally be 1, but if the resource is generated by a
 616         ResourceGroup **and** an env file is present, then the count will be
 617         the value from the env file (assuming this follows standard VNF Heat
 618         Guidelines)
 619         """
 620         base_dir = base_dir or self.dirname
 621         resources = {}
 622         for r_id, r_data in self.resources.items():
 623             r_data["__count__"] = count
 624             resources[r_id] = r_data
 625             resource = Resource(r_id, r_data)
 626             if resource.is_nested():
 627                 nested_count = resource.get_count(self.env)
 628                 nested = Heat(os.path.join(base_dir, resource.get_nested_filename()))
 629                 nested_resources = nested.get_all_resources(count=nested_count)
 630                 resources.update(nested_resources)
 631         return resources
 632
 633     @staticmethod
 634     def get_heat_processors():
 635         """Return a dict, key is resource_type, value is the
 636         HeatProcessor subclass whose resource_type is the key.
 637         """
 638         return _HEAT_PROCESSORS
 639
 640     def get_resource_by_type(self, resource_type, all_resources=False):
 641         """Return dict of resources whose type is `resource_type`.
 642         key is resource_id, value is resource.
 643         """
 644         resources = self.get_all_resources() if all_resources else self.resources
 645         return {
 646             rid: resource
 647             for rid, resource in resources.items()
 648             if self.nested_get(resource, "type") == resource_type
 649         }
 650
 651     def get_rid_match_tuple(self, rid, resource_type):
 652         """return get_rid_match_tuple(rid) called on the class
 653         corresponding to the given resource_type.
 654         """
 655         processor = self.heat_processors.get(resource_type, HeatProcessor)
 656         return processor.get_rid_match_tuple(rid)
 657
 658     def get_vm_type(self, rid, resource=None):
 659         """return the vm_type
 660         """
 661         if resource is None:
 662             resource = self
 663         resource_type = self.nested_get(resource, "type")
 664         match = self.get_rid_match_tuple(rid, resource_type)[1]
 665         vm_type = match.groupdict().get("vm_type") if match else None
 666         return vm_type
 667
 668     def load(self, filepath):
 669         """Load the Heat template given a filepath.
 670         """
 671         self.filepath = filepath
 672         self.basename = os.path.basename(self.filepath)
 673         self.dirname = os.path.dirname(self.filepath)
 674         with open(self.filepath) as fi:
 675             self.yml = yaml.load(fi)
 676         self.heat_template_version = self.yml.get("heat_template_version", None)
 677         self.description = self.yml.get("description", "")
 678         self.parameter_groups = self.yml.get("parameter_groups") or {}
 679         self.parameters = self.yml.get("parameters") or {}
 680         self.resources = self.yml.get("resources") or {}
 681         self.outputs = self.yml.get("outputs") or {}
 682         self.conditions = self.yml.get("conditions") or {}
 683
 684     def load_env(self, envpath):
 685         """Load the Environment template given a envpath.
 686         """
 687         self.env = Env(filepath=envpath)
 688
 689     @staticmethod
 690     def nested_get(dic, *keys, **kwargs):
 691         """make utils.nested_dict.get available as a class method.
 692         """
 693         return nested_dict.get(dic, *keys, **kwargs)
 694
 695     @property
 696     def neutron_port_resources(self):
 697         """This attribute is a dict of Neutron Ports
 698         """
 699         return self.get_resource_by_type(
 700             resource_type=NeutronPortProcessor.resource_type
 701         )
 702
 703     @property
 704     def nova_server_resources(self):
 705         """This attribute is a dict of Nova Servers
 706         """
 707         return self.get_resource_by_type(
 708             resource_type=NovaServerProcessor.resource_type
 709         )
 710
 711     @staticmethod
 712     def part_is_in_name(part, name):
 713         """
 714         Return True if any of
 715         - name starts with part + '_'
 716         - name contains '_' + part + '_'
 717         - name ends with '_' + part
 718         False otherwise
 719         """
 720         return bool(
 721             re.search("(^(%(x)s)_)|(_(%(x)s)_)|(_(%(x)s)$)" % dict(x=part), name)
 722         )
 723
 724
 725 class Env(Heat):
 726     """An Environment file
 727     """
 728
 729     pass
 730
 731
 732 class Resource(object):
 733     """A Resource
 734     """
 735
 736     def __init__(self, resource_id=None, resource=None):
 737         self.resource_id = resource_id or ""
 738         self.resource = resource or {}
 739         self.properties = self.resource.get("properties", {})
 740         self.resource_type = self.resource.get("type", "")
 741
 742     @staticmethod
 743     def get_index_var(resource):
 744         """Return the index_var for this resource.
 745         """
 746         index_var = nested_dict.get(resource, "properties", "index_var") or "index"
 747         return index_var
 748
 749     def get_nested_filename(self):
 750         """Returns the filename of the nested YAML file if the
 751         resource is a nested YAML or ResourceDef, returns '' otherwise."""
 752         typ = self.resource.get("type", "")
 753         if typ == "OS::Heat::ResourceGroup":
 754             rd = nested_dict.get(self.resource, "properties", "resource_def")
 755             typ = rd.get("type", "") if rd else ""
 756         ext = os.path.splitext(typ)[1]
 757         ext = ext.lower()
 758         if ext == ".yml" or ext == ".yaml":
 759             return typ
 760         else:
 761             return ""
 762
 763     def get_nested_properties(self):
 764         """
 765         Returns {} if not nested
 766         Returns resource: properties if nested
 767         Returns resource: properties: resource_def: properties if RG
 768         """
 769         if not bool(self.get_nested_filename()):
 770             return {}
 771         elif self.resource_type == "OS::Heat::ResourceGroup":
 772             return nested_dict.get(
 773                 self.properties, "resource_def", "properties", default={}
 774             )
 775         else:
 776             return self.properties
 777
 778     def get_count(self, env):
 779         if self.resource_type == "OS::Heat::ResourceGroup":
 780             if not env:
 781                 return 1
 782             env_params = env.parameters
 783             count_param = get_param(self.properties["count"])
 784             count_value = env_params.get(count_param) if count_param else 1
 785             try:
 786                 return int(count_value)
 787             except (ValueError, TypeError):
 788                 print((
 789                     "WARNING: Invalid value for count parameter {}. Expected "
 790                     "an integer, but got {}. Defaulting to 1"
 791                 ).format(count_param, count_value))
 792         return 1
 793
 794     @property
 795     def depends_on(self):
 796         """
 797         Returns the list of resources this resource depends on.  Always
 798         returns a list.
 799
 800         :return: list of all resource IDs this resource depends on.  If none,
 801                  then returns an empty list
 802         """
 803         parents = self.resource.get("depends_on", [])
 804         return parents if isinstance(parents, list) else [parents]
 805
 806     def is_nested(self):
 807         """Returns True if the resource represents a Nested YAML resource
 808         using either type: {filename} or ResourceGroup -> resource_def"""
 809         return bool(self.get_nested_filename())
 810
 811     def get_nested_yaml(self, base_dir):
 812         """If the resource represents a Nested YAML resource, then it
 813         returns the loaded YAML.  If the resource is not nested or the
 814         file cannot be found, then an empty dict is returned"""
 815         filename = self.get_nested_filename()
 816         if filename:
 817             file_path = os.path.join(base_dir, filename)
 818             return load_yaml(file_path) if os.path.exists(file_path) else {}
 819         else:
 820             return {}
 821
 822
 823 def get_all_resources(yaml_files):
 824     """Return a dict, resource id: resource
 825     of the union of resources across all files.
 826     """
 827     resources = {}
 828     for heat_template in yaml_files:
 829         heat = Heat(filepath=heat_template)
 830         dirname = os.path.dirname(heat_template)
 831         resources.update(heat.get_all_resources(dirname))
 832     return resources
 833
 834
 835 def _get_heat_processors():
 836     """Introspect this module and return a
 837     dict of all HeatProcessor sub-classes with a (True) resource_type.
 838     Key is the resource_type, value is the corrresponding class.
 839     """
 840     mod_classes = inspect.getmembers(sys.modules[__name__], inspect.isclass)
 841     heat_processors = {
 842         c.resource_type: c
 843         for _, c in mod_classes
 844         if issubclass(c, HeatProcessor) and c.resource_type
 845     }
 846     return heat_processors
 847
 848
 849 _HEAT_PROCESSORS = _get_heat_processors()