validate.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321
  1. """User input parameter validation.
  2. This module handles user input parameter validation
  3. against a provided input model.
  4. Note that the objects in this module do *not* mutate any
  5. arguments. No type version happens here. It is up to another
  6. layer to properly convert arguments to any required types.
  7. Validation Errors
  8. -----------------
  9. """
  10. from botocore.compat import six
  11. import decimal
  12. import json
  13. from datetime import datetime
  14. from botocore.utils import parse_to_aware_datetime
  15. from botocore.utils import is_json_value_header
  16. from botocore.exceptions import ParamValidationError
  17. def validate_parameters(params, shape):
  18. """Validates input parameters against a schema.
  19. This is a convenience function that validates parameters against a schema.
  20. You can also instantiate and use the ParamValidator class directly if you
  21. want more control.
  22. If there are any validation errors then a ParamValidationError
  23. will be raised. If there are no validation errors than no exception
  24. is raised and a value of None is returned.
  25. :param params: The user provided input parameters.
  26. :type shape: botocore.model.Shape
  27. :param shape: The schema which the input parameters should
  28. adhere to.
  29. :raise: ParamValidationError
  30. """
  31. validator = ParamValidator()
  32. report = validator.validate(params, shape)
  33. if report.has_errors():
  34. raise ParamValidationError(report=report.generate_report())
  35. def type_check(valid_types):
  36. def _create_type_check_guard(func):
  37. def _on_passes_type_check(self, param, shape, errors, name):
  38. if _type_check(param, errors, name):
  39. return func(self, param, shape, errors, name)
  40. def _type_check(param, errors, name):
  41. if not isinstance(param, valid_types):
  42. valid_type_names = [six.text_type(t) for t in valid_types]
  43. errors.report(name, 'invalid type', param=param,
  44. valid_types=valid_type_names)
  45. return False
  46. return True
  47. return _on_passes_type_check
  48. return _create_type_check_guard
  49. def range_check(name, value, shape, error_type, errors):
  50. failed = False
  51. min_allowed = float('-inf')
  52. if 'min' in shape.metadata:
  53. min_allowed = shape.metadata['min']
  54. if value < min_allowed:
  55. failed = True
  56. elif hasattr(shape, 'serialization'):
  57. # Members that can be bound to the host have an implicit min of 1
  58. if shape.serialization.get('hostLabel'):
  59. min_allowed = 1
  60. if value < min_allowed:
  61. failed = True
  62. if failed:
  63. errors.report(name, error_type, param=value, min_allowed=min_allowed)
  64. class ValidationErrors(object):
  65. def __init__(self):
  66. self._errors = []
  67. def has_errors(self):
  68. if self._errors:
  69. return True
  70. return False
  71. def generate_report(self):
  72. error_messages = []
  73. for error in self._errors:
  74. error_messages.append(self._format_error(error))
  75. return '\n'.join(error_messages)
  76. def _format_error(self, error):
  77. error_type, name, additional = error
  78. name = self._get_name(name)
  79. if error_type == 'missing required field':
  80. return 'Missing required parameter in %s: "%s"' % (
  81. name, additional['required_name'])
  82. elif error_type == 'unknown field':
  83. return 'Unknown parameter in %s: "%s", must be one of: %s' % (
  84. name, additional['unknown_param'],
  85. ', '.join(additional['valid_names']))
  86. elif error_type == 'invalid type':
  87. return 'Invalid type for parameter %s, value: %s, type: %s, ' \
  88. 'valid types: %s' % (name, additional['param'],
  89. str(type(additional['param'])),
  90. ', '.join(additional['valid_types']))
  91. elif error_type == 'invalid range':
  92. min_allowed = additional['min_allowed']
  93. return ('Invalid value for parameter %s, value: %s, '
  94. 'valid min value: %s' % (name, additional['param'],
  95. min_allowed))
  96. elif error_type == 'invalid length':
  97. min_allowed = additional['min_allowed']
  98. return ('Invalid length for parameter %s, value: %s, '
  99. 'valid min length: %s' % (name, additional['param'],
  100. min_allowed))
  101. elif error_type == 'unable to encode to json':
  102. return 'Invalid parameter %s must be json serializable: %s' \
  103. % (name, additional['type_error'])
  104. elif error_type == 'invalid type for document':
  105. return 'Invalid type for document parameter %s, value: %s, type: %s, ' \
  106. 'valid types: %s' % (name, additional['param'],
  107. str(type(additional['param'])),
  108. ', '.join(additional['valid_types']))
  109. def _get_name(self, name):
  110. if not name:
  111. return 'input'
  112. elif name.startswith('.'):
  113. return name[1:]
  114. else:
  115. return name
  116. def report(self, name, reason, **kwargs):
  117. self._errors.append((reason, name, kwargs))
  118. class ParamValidator(object):
  119. """Validates parameters against a shape model."""
  120. def validate(self, params, shape):
  121. """Validate parameters against a shape model.
  122. This method will validate the parameters against a provided shape model.
  123. All errors will be collected before returning to the caller. This means
  124. that this method will not stop at the first error, it will return all
  125. possible errors.
  126. :param params: User provided dict of parameters
  127. :param shape: A shape model describing the expected input.
  128. :return: A list of errors.
  129. """
  130. errors = ValidationErrors()
  131. self._validate(params, shape, errors, name='')
  132. return errors
  133. def _check_special_validation_cases(self, shape):
  134. if is_json_value_header(shape):
  135. return self._validate_jsonvalue_string
  136. if shape.type_name == 'structure' and shape.is_document_type:
  137. return self._validate_document
  138. def _validate(self, params, shape, errors, name):
  139. special_validator = self._check_special_validation_cases(shape)
  140. if special_validator:
  141. special_validator(params, shape, errors, name)
  142. else:
  143. getattr(self, '_validate_%s' % shape.type_name)(
  144. params, shape, errors, name)
  145. def _validate_jsonvalue_string(self, params, shape, errors, name):
  146. # Check to see if a value marked as a jsonvalue can be dumped to
  147. # a json string.
  148. try:
  149. json.dumps(params)
  150. except (ValueError, TypeError) as e:
  151. errors.report(name, 'unable to encode to json', type_error=e)
  152. def _validate_document(self, params, shape, errors, name):
  153. if params is None:
  154. return
  155. if isinstance(params, dict):
  156. for key in params:
  157. self._validate_document(params[key], shape, errors, key)
  158. elif isinstance(params, list):
  159. for index, entity in enumerate(params):
  160. self._validate_document(entity, shape, errors,
  161. '%s[%d]' % (name, index))
  162. elif not isinstance(params, (six.string_types, int, bool, float)):
  163. valid_types = (str, int, bool, float, list, dict)
  164. valid_type_names = [six.text_type(t) for t in valid_types]
  165. errors.report(name, 'invalid type for document',
  166. param=params,
  167. param_type=type(params),
  168. valid_types=valid_type_names)
  169. @type_check(valid_types=(dict,))
  170. def _validate_structure(self, params, shape, errors, name):
  171. # Validate required fields.
  172. for required_member in shape.metadata.get('required', []):
  173. if required_member not in params:
  174. errors.report(name, 'missing required field',
  175. required_name=required_member, user_params=params)
  176. members = shape.members
  177. known_params = []
  178. # Validate known params.
  179. for param in params:
  180. if param not in members:
  181. errors.report(name, 'unknown field', unknown_param=param,
  182. valid_names=list(members))
  183. else:
  184. known_params.append(param)
  185. # Validate structure members.
  186. for param in known_params:
  187. self._validate(params[param], shape.members[param],
  188. errors, '%s.%s' % (name, param))
  189. @type_check(valid_types=six.string_types)
  190. def _validate_string(self, param, shape, errors, name):
  191. # Validate range. For a string, the min/max contraints
  192. # are of the string length.
  193. # Looks like:
  194. # "WorkflowId":{
  195. # "type":"string",
  196. # "min":1,
  197. # "max":256
  198. # }
  199. range_check(name, len(param), shape, 'invalid length', errors)
  200. @type_check(valid_types=(list, tuple))
  201. def _validate_list(self, param, shape, errors, name):
  202. member_shape = shape.member
  203. range_check(name, len(param), shape, 'invalid length', errors)
  204. for i, item in enumerate(param):
  205. self._validate(item, member_shape, errors, '%s[%s]' % (name, i))
  206. @type_check(valid_types=(dict,))
  207. def _validate_map(self, param, shape, errors, name):
  208. key_shape = shape.key
  209. value_shape = shape.value
  210. for key, value in param.items():
  211. self._validate(key, key_shape, errors, "%s (key: %s)"
  212. % (name, key))
  213. self._validate(value, value_shape, errors, '%s.%s' % (name, key))
  214. @type_check(valid_types=six.integer_types)
  215. def _validate_integer(self, param, shape, errors, name):
  216. range_check(name, param, shape, 'invalid range', errors)
  217. def _validate_blob(self, param, shape, errors, name):
  218. if isinstance(param, (bytes, bytearray, six.text_type)):
  219. return
  220. elif hasattr(param, 'read'):
  221. # File like objects are also allowed for blob types.
  222. return
  223. else:
  224. errors.report(name, 'invalid type', param=param,
  225. valid_types=[str(bytes), str(bytearray),
  226. 'file-like object'])
  227. @type_check(valid_types=(bool,))
  228. def _validate_boolean(self, param, shape, errors, name):
  229. pass
  230. @type_check(valid_types=(float, decimal.Decimal) + six.integer_types)
  231. def _validate_double(self, param, shape, errors, name):
  232. range_check(name, param, shape, 'invalid range', errors)
  233. _validate_float = _validate_double
  234. @type_check(valid_types=six.integer_types)
  235. def _validate_long(self, param, shape, errors, name):
  236. range_check(name, param, shape, 'invalid range', errors)
  237. def _validate_timestamp(self, param, shape, errors, name):
  238. # We don't use @type_check because datetimes are a bit
  239. # more flexible. You can either provide a datetime
  240. # object, or a string that parses to a datetime.
  241. is_valid_type = self._type_check_datetime(param)
  242. if not is_valid_type:
  243. valid_type_names = [six.text_type(datetime), 'timestamp-string']
  244. errors.report(name, 'invalid type', param=param,
  245. valid_types=valid_type_names)
  246. def _type_check_datetime(self, value):
  247. try:
  248. parse_to_aware_datetime(value)
  249. return True
  250. except (TypeError, ValueError, AttributeError):
  251. # Yes, dateutil can sometimes raise an AttributeError
  252. # when parsing timestamps.
  253. return False
  254. class ParamValidationDecorator(object):
  255. def __init__(self, param_validator, serializer):
  256. self._param_validator = param_validator
  257. self._serializer = serializer
  258. def serialize_to_request(self, parameters, operation_model):
  259. input_shape = operation_model.input_shape
  260. if input_shape is not None:
  261. report = self._param_validator.validate(parameters,
  262. operation_model.input_shape)
  263. if report.has_errors():
  264. raise ParamValidationError(report=report.generate_report())
  265. return self._serializer.serialize_to_request(parameters,
  266. operation_model)