File size: 7,701 Bytes
b40c49c | 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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | """
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: MIT-0
"""
from __future__ import annotations
from collections import deque
from typing import Any, Sequence
import regex as re
from cfnlint.helpers import ensure_list, is_types_compatible
from cfnlint.jsonschema import ValidationError, ValidationResult, Validator
from cfnlint.rules.functions._BaseFn import BaseFn, all_types
from cfnlint.schema import PROVIDER_SCHEMA_MANAGER
class GetAtt(BaseFn):
"""Check if GetAtt values are correct"""
id = "E1010"
shortdesc = "GetAtt validation of parameters"
description = (
"Validates that GetAtt parameters are to valid resources and properties of"
" those resources"
)
source_url = "https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html"
tags = ["functions", "getatt"]
def __init__(self) -> None:
super().__init__("Fn::GetAtt", all_types)
def schema(self, validator, instance) -> dict[str, Any]:
resource_name_functions = []
resource_attribute_functions = ["Ref"]
if validator.context.transforms.has_language_extensions_transform():
resource_name_functions = resource_attribute_functions = [
"Ref",
"Fn::Base64",
"Fn::FindInMap",
"Fn::Sub",
"Fn::If",
"Fn::Join",
"Fn::ToJsonString",
]
return {
"type": ["string", "array"],
"minItems": 2,
"maxItems": 2,
"fn_items": [
{
"functions": resource_name_functions,
"schema": {
"type": ["string"],
},
},
{
"functions": resource_attribute_functions,
"schema": {
"type": ["string"],
},
},
],
}
def _resolve_getatt(
self,
validator: Validator,
key: str,
value: Any,
instance: Any,
s: Any,
paths: Sequence[Any],
) -> ValidationResult:
for resource_name, resource_name_validator, _ in validator.resolve_value(
value[0]
):
for err in self.fix_errors(
resource_name_validator.descend(
resource_name,
{"enum": list(validator.context.resources.keys())},
path=key,
)
):
err.path.append(paths[0])
if err.instance != value[0]:
err.message = err.message + f" when {value[0]!r} is resolved"
yield err
break
else:
t = validator.context.resources[resource_name].type
for (
regions,
schema,
) in PROVIDER_SCHEMA_MANAGER.get_resource_schemas_by_regions(
t, validator.context.regions
):
region = regions[0]
for attribute_name, _, _ in validator.resolve_value(value[1]):
if all(
not (bool(re.fullmatch(each, attribute_name)))
for each in validator.context.resources[
resource_name
].get_atts(region)
):
err = ValidationError(
(
f"{attribute_name!r} is not one of "
f"{validator.context.resources[resource_name].get_atts(region)!r}"
f" in {regions!r}"
),
validator=self.fn.py,
path=deque([self.fn.name, 1]),
)
if attribute_name != value[1]:
err.message = (
err.message + f" when {value[1]!r} is resolved"
)
yield err
continue
evolved = validator.evolve(schema=s) # type: ignore
evolved.validators = { # type: ignore
"type": validator.validators.get("type"), # type: ignore
}
getatts = validator.cfn.get_valid_getatts()
t = validator.context.resources[resource_name].type
pointer = getatts.match(region, [resource_name, attribute_name])
getatt_schema = schema.resolver.resolve_cfn_pointer(pointer)
# there is one exception we need to handle. The resource type
# has a mix of types the input is integer and the output
# is string. Since this is the only occurence
# we are putting in an exception to it.
if (
validator.context.resources[resource_name].type
== "AWS::DocDB::DBCluster"
and attribute_name == "Port"
):
getatt_schema = {"type": "string"}
if not getatt_schema.get("type") or not s.get("type"):
continue
schema_types = ensure_list(getatt_schema.get("type"))
types = ensure_list(s.get("type"))
# GetAtt type checking is strict.
# It must match in all cases
if any(t in ["boolean", "integer", "boolean"] for t in types):
# this should be switched to validate the value of the
# property if it was available
continue
if is_types_compatible(types, schema_types, True):
continue
reprs = ", ".join(repr(type) for type in types)
yield ValidationError(
(f"{instance!r} is not of type {reprs}"),
validator=self.fn.py,
path=deque([self.fn.name]),
schema_path=deque(["type"]),
)
def fn_getatt(
self, validator: Validator, s: Any, instance: Any, schema: Any
) -> ValidationResult:
errs = list(super().validate(validator, s, instance, schema))
if errs:
yield from iter(errs)
return
key, value = self.key_value(instance)
paths: list[int | None] = [0, 1]
if validator.is_type(value, "string"):
paths = [None, None]
value = value.split(".", 1)
errs = list(
self._resolve_getatt(
self.validator(validator), key, value, instance, s, paths
)
)
if errs:
yield from iter(errs)
return
keyword = validator.context.path.cfn_path_string
for rule in self.child_rules.values():
if rule is None:
continue
if keyword in rule.keywords or "*" in rule.keywords: # type: ignore
yield from rule.validate(validator, s, value, s) # type: ignore
|