Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/botocore/handlers.py: 22%

1# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved. 

2# 

3# Licensed under the Apache License, Version 2.0 (the "License"). You 

4# may not use this file except in compliance with the License. A copy of 

5# the License is located at 

6# 

7# http://aws.amazon.com/apache2.0/ 

8# 

9# or in the "license" file accompanying this file. This file is 

10# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 

11# ANY KIND, either express or implied. See the License for the specific 

12# language governing permissions and limitations under the License. 

13 

14"""Builtin event handlers. 

15 

16This module contains builtin handlers for events emitted by botocore. 

17""" 

18 

19import base64 

20import copy 

21import logging 

22import os 

23import re 

24import uuid 

25import warnings 

26from io import BytesIO 

27 

28import botocore 

29import botocore.auth 

30from botocore import ( 

31 retryhandler, # noqa: F401 

32 translate, # noqa: F401 

33 utils, 

34) 

35from botocore.args import ClientConfigString 

36from botocore.compat import ( 

37 MD5_AVAILABLE, # noqa: F401 

38 ETree, 

39 OrderedDict, 

40 XMLParseError, 

41 ensure_bytes, 

42 get_md5, 

43 json, 

44 quote, 

45 unquote, 

46 unquote_str, 

47 urlsplit, 

48 urlunsplit, 

49) 

50from botocore.docs.utils import ( 

51 AppendParamDocumentation, 

52 AutoPopulatedParam, 

53 HideParamFromOperations, 

54) 

55from botocore.endpoint_provider import VALID_HOST_LABEL_RE 

56from botocore.exceptions import ( 

57 AliasConflictParameterError, 

58 MissingServiceIdError, # noqa: F401 

59 ParamValidationError, 

60 UnsupportedTLSVersionWarning, 

61) 

62from botocore.regions import EndpointResolverBuiltins 

63from botocore.signers import ( 

64 add_dsql_generate_db_auth_token_methods, 

65 add_generate_db_auth_token, 

66 add_generate_presigned_post, 

67 add_generate_presigned_url, 

68) 

69from botocore.useragent import register_feature_id 

70from botocore.utils import ( 

71 SAFE_CHARS, 

72 SERVICE_NAME_ALIASES, # noqa: F401 

73 ArnParser, 

74 get_token_from_environment, 

75 hyphenize_service_id, # noqa: F401 

76 is_global_accesspoint, # noqa: F401 

77 percent_encode, 

78 switch_host_with_param, 

79) 

80 

81logger = logging.getLogger(__name__) 

82 

83REGISTER_FIRST = object() 

84REGISTER_LAST = object() 

85# From the S3 docs: 

86# The rules for bucket names in the US Standard region allow bucket names 

87# to be as long as 255 characters, and bucket names can contain any 

88# combination of uppercase letters, lowercase letters, numbers, periods 

89# (.), hyphens (-), and underscores (_). 

90VALID_BUCKET = re.compile(r'^[a-zA-Z0-9.\-_]{1,255}$') 

91_ACCESSPOINT_ARN = ( 

92 r'^arn:(aws).*:(s3|s3-object-lambda):[a-z\-0-9]*:[0-9]{12}:accesspoint[/:]' 

93 r'[a-zA-Z0-9\-.]{1,63}$' 

94) 

95_OUTPOST_ARN = ( 

96 r'^arn:(aws).*:s3-outposts:[a-z\-0-9]+:[0-9]{12}:outpost[/:]' 

97 r'[a-zA-Z0-9\-]{1,63}[/:]accesspoint[/:][a-zA-Z0-9\-]{1,63}$' 

98) 

99VALID_S3_ARN = re.compile('|'.join([_ACCESSPOINT_ARN, _OUTPOST_ARN])) 

100# signing names used for the services s3 and s3-control, for example in 

101# botocore/data/s3/2006-03-01/endpoints-rule-set-1.json 

102S3_SIGNING_NAMES = ('s3', 's3-outposts', 's3-object-lambda', 's3express') 

103VERSION_ID_SUFFIX = re.compile(r'\?versionId=[^\s]+$') 

104 

105 

106def handle_service_name_alias(service_name, **kwargs): 

107 return SERVICE_NAME_ALIASES.get(service_name, service_name) 

108 

109 

110def add_recursion_detection_header(params, **kwargs): 

111 has_lambda_name = 'AWS_LAMBDA_FUNCTION_NAME' in os.environ 

112 trace_id = os.environ.get('_X_AMZN_TRACE_ID') 

113 if has_lambda_name and trace_id: 

114 headers = params['headers'] 

115 if 'X-Amzn-Trace-Id' not in headers: 

116 headers['X-Amzn-Trace-Id'] = quote(trace_id, safe='-=;:+&[]{}"\',') 

117 

118 

119def escape_xml_payload(params, **kwargs): 

120 # Replace \r and \n with the escaped sequence over the whole XML document 

121 # to avoid linebreak normalization modifying customer input when the 

122 # document is parsed. Ideally, we would do this in ElementTree.tostring, 

123 # but it doesn't allow us to override entity escaping for text fields. For 

124 # this operation \r and \n can only appear in the XML document if they were 

125 # passed as part of the customer input. 

126 body = params['body'] 

127 if b'\r' in body: 

128 body = body.replace(b'\r', b'
') 

129 if b'\n' in body: 

130 body = body.replace(b'\n', b'
') 

131 

132 params['body'] = body 

133 

134 

135def check_for_200_error(response, **kwargs): 

136 """This function has been deprecated, but is kept for backwards compatibility.""" 

137 # From: http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html 

138 # There are two opportunities for a copy request to return an error. One 

139 # can occur when Amazon S3 receives the copy request and the other can 

140 # occur while Amazon S3 is copying the files. If the error occurs before 

141 # the copy operation starts, you receive a standard Amazon S3 error. If the 

142 # error occurs during the copy operation, the error response is embedded in 

143 # the 200 OK response. This means that a 200 OK response can contain either 

144 # a success or an error. Make sure to design your application to parse the 

145 # contents of the response and handle it appropriately. 

146 # 

147 # So this handler checks for this case. Even though the server sends a 

148 # 200 response, conceptually this should be handled exactly like a 

149 # 500 response (with respect to raising exceptions, retries, etc.) 

150 # We're connected *before* all the other retry logic handlers, so as long 

151 # as we switch the error code to 500, we'll retry the error as expected. 

152 if response is None: 

153 # A None response can happen if an exception is raised while 

154 # trying to retrieve the response. See Endpoint._get_response(). 

155 return 

156 http_response, parsed = response 

157 if _looks_like_special_case_error( 

158 http_response.status_code, http_response.content 

159 ): 

160 logger.debug( 

161 "Error found for response with 200 status code, " 

162 "errors: %s, changing status code to " 

163 "500.", 

164 parsed, 

165 ) 

166 http_response.status_code = 500 

167 

168 

169def _looks_like_special_case_error(status_code, body): 

170 if status_code == 200 and body: 

171 try: 

172 parser = ETree.XMLParser( 

173 target=ETree.TreeBuilder(), encoding='utf-8' 

174 ) 

175 parser.feed(body) 

176 root = parser.close() 

177 except XMLParseError: 

178 # In cases of network disruptions, we may end up with a partial 

179 # streamed response from S3. We need to treat these cases as 

180 # 500 Service Errors and try again. 

181 return True 

182 if root.tag == 'Error': 

183 return True 

184 return False 

185 

186 

187def set_operation_specific_signer(context, signing_name, **kwargs): 

188 """Choose the operation-specific signer. 

189 

190 Individual operations may have a different auth type than the service as a 

191 whole. This will most often manifest as operations that should not be 

192 authenticated at all, but can include other auth modes such as sigv4 

193 without body signing. 

194 """ 

195 auth_type = context.get('auth_type') 

196 

197 # Auth type will be None if the operation doesn't have a configured auth 

198 # type. 

199 if not auth_type: 

200 return 

201 

202 # Auth type will be the string value 'none' if the operation should not 

203 # be signed at all. 

204 if auth_type == 'none': 

205 return botocore.UNSIGNED 

206 

207 if auth_type == 'bearer': 

208 return 'bearer' 

209 

210 # If the operation needs an unsigned body, we set additional context 

211 # allowing the signer to be aware of this. 

212 if context.get('unsigned_payload') or auth_type == 'v4-unsigned-body': 

213 context['payload_signing_enabled'] = False 

214 

215 if auth_type.startswith('v4'): 

216 if auth_type == 'v4-s3express': 

217 return auth_type 

218 

219 if auth_type == 'v4a': 

220 # If sigv4a is chosen, we must add additional signing config for 

221 # global signature. 

222 region = _resolve_sigv4a_region(context) 

223 signing = {'region': region, 'signing_name': signing_name} 

224 if 'signing' in context: 

225 context['signing'].update(signing) 

226 else: 

227 context['signing'] = signing 

228 signature_version = 'v4a' 

229 else: 

230 signature_version = 'v4' 

231 

232 # Signing names used by s3 and s3-control use customized signers "s3v4" 

233 # and "s3v4a". 

234 if signing_name in S3_SIGNING_NAMES: 

235 signature_version = f's3{signature_version}' 

236 

237 return signature_version 

238 

239 

240def _resolve_sigv4a_region(context): 

241 region = None 

242 if 'client_config' in context: 

243 region = context['client_config'].sigv4a_signing_region_set 

244 if not region and context.get('signing', {}).get('region'): 

245 region = context['signing']['region'] 

246 return region or '*' 

247 

248 

249def decode_console_output(parsed, **kwargs): 

250 if 'Output' in parsed: 

251 try: 

252 # We're using 'replace' for errors because it is 

253 # possible that console output contains non string 

254 # chars we can't utf-8 decode. 

255 value = base64.b64decode( 

256 bytes(parsed['Output'], 'latin-1') 

257 ).decode('utf-8', 'replace') 

258 parsed['Output'] = value 

259 except (ValueError, TypeError, AttributeError): 

260 logger.debug('Error decoding base64', exc_info=True) 

261 

262 

263def generate_idempotent_uuid(params, model, **kwargs): 

264 for name in model.idempotent_members: 

265 if name not in params: 

266 params[name] = str(uuid.uuid4()) 

267 logger.debug( 

268 f"injecting idempotency token ({params[name]}) into param '{name}'." 

269 ) 

270 

271 

272def decode_quoted_jsondoc(value): 

273 try: 

274 value = json.loads(unquote(value)) 

275 except (ValueError, TypeError): 

276 logger.debug('Error loading quoted JSON', exc_info=True) 

277 return value 

278 

279 

280def json_decode_template_body(parsed, **kwargs): 

281 if 'TemplateBody' in parsed: 

282 try: 

283 value = json.loads( 

284 parsed['TemplateBody'], object_pairs_hook=OrderedDict 

285 ) 

286 parsed['TemplateBody'] = value 

287 except (ValueError, TypeError): 

288 logger.debug('error loading JSON', exc_info=True) 

289 

290 

291def validate_bucket_name(params, **kwargs): 

292 if 'Bucket' not in params: 

293 return 

294 bucket = params['Bucket'] 

295 if not VALID_BUCKET.search(bucket) and not VALID_S3_ARN.search(bucket): 

296 error_msg = ( 

297 f'Invalid bucket name "{bucket}": Bucket name must match ' 

298 f'the regex "{VALID_BUCKET.pattern}" or be an ARN matching ' 

299 f'the regex "{VALID_S3_ARN.pattern}"' 

300 ) 

301 raise ParamValidationError(report=error_msg) 

302 

303 

304def sse_md5(params, **kwargs): 

305 """ 

306 S3 server-side encryption requires the encryption key to be sent to the 

307 server base64 encoded, as well as a base64-encoded MD5 hash of the 

308 encryption key. This handler does both if the MD5 has not been set by 

309 the caller. 

310 """ 

311 _sse_md5(params, 'SSECustomer') 

312 

313 

314def copy_source_sse_md5(params, **kwargs): 

315 """ 

316 S3 server-side encryption requires the encryption key to be sent to the 

317 server base64 encoded, as well as a base64-encoded MD5 hash of the 

318 encryption key. This handler does both if the MD5 has not been set by 

319 the caller specifically if the parameter is for the copy-source sse-c key. 

320 """ 

321 _sse_md5(params, 'CopySourceSSECustomer') 

322 

323 

324def _sse_md5(params, sse_member_prefix='SSECustomer'): 

325 if not _needs_s3_sse_customization(params, sse_member_prefix): 

326 return 

327 

328 sse_key_member = sse_member_prefix + 'Key' 

329 sse_md5_member = sse_member_prefix + 'KeyMD5' 

330 key_as_bytes = params[sse_key_member] 

331 if isinstance(key_as_bytes, str): 

332 key_as_bytes = key_as_bytes.encode('utf-8') 

333 md5_val = get_md5(key_as_bytes, usedforsecurity=False).digest() 

334 key_md5_str = base64.b64encode(md5_val).decode('utf-8') 

335 key_b64_encoded = base64.b64encode(key_as_bytes).decode('utf-8') 

336 params[sse_key_member] = key_b64_encoded 

337 params[sse_md5_member] = key_md5_str 

338 

339 

340def _needs_s3_sse_customization(params, sse_member_prefix): 

341 return ( 

342 params.get(sse_member_prefix + 'Key') is not None 

343 and sse_member_prefix + 'KeyMD5' not in params 

344 ) 

345 

346 

347def disable_signing(**kwargs): 

348 """ 

349 This handler disables request signing by setting the signer 

350 name to a special sentinel value. 

351 """ 

352 return botocore.UNSIGNED 

353 

354 

355def add_expect_header(model, params, **kwargs): 

356 if model.http.get('method', '') not in ['PUT', 'POST']: 

357 return 

358 if 'body' in params: 

359 body = params['body'] 

360 if hasattr(body, 'read'): 

361 check_body = utils.ensure_boolean( 

362 os.environ.get( 

363 'BOTO_EXPERIMENTAL__NO_EMPTY_CONTINUE', 

364 False, 

365 ) 

366 ) 

367 if check_body and utils.determine_content_length(body) == 0: 

368 return 

369 # Any file like object will use an expect 100-continue 

370 # header regardless of size. 

371 logger.debug("Adding expect 100 continue header to request.") 

372 params['headers']['Expect'] = '100-continue' 

373 

374 

375class DeprecatedServiceDocumenter: 

376 def __init__(self, replacement_service_name): 

377 self._replacement_service_name = replacement_service_name 

378 

379 def inject_deprecation_notice(self, section, event_name, **kwargs): 

380 section.style.start_important() 

381 section.write('This service client is deprecated. Please use ') 

382 section.style.ref( 

383 self._replacement_service_name, 

384 self._replacement_service_name, 

385 ) 

386 section.write(' instead.') 

387 section.style.end_important() 

388 

389 

390def document_copy_source_form(section, event_name, **kwargs): 

391 if 'request-example' in event_name: 

392 parent = section.get_section('structure-value') 

393 param_line = parent.get_section('CopySource') 

394 value_portion = param_line.get_section('member-value') 

395 value_portion.clear_text() 

396 value_portion.write( 

397 "'string' or {'Bucket': 'string', " 

398 "'Key': 'string', 'VersionId': 'string'}" 

399 ) 

400 elif 'request-params' in event_name: 

401 param_section = section.get_section('CopySource') 

402 type_section = param_section.get_section('param-type') 

403 type_section.clear_text() 

404 type_section.write(':type CopySource: str or dict') 

405 doc_section = param_section.get_section('param-documentation') 

406 doc_section.clear_text() 

407 doc_section.write( 

408 "The name of the source bucket, key name of the source object, " 

409 "and optional version ID of the source object. You can either " 

410 "provide this value as a string or a dictionary. The " 

411 "string form is {bucket}/{key} or " 

412 "{bucket}/{key}?versionId={versionId} if you want to copy a " 

413 "specific version. You can also provide this value as a " 

414 "dictionary. The dictionary format is recommended over " 

415 "the string format because it is more explicit. The dictionary " 

416 "format is: {'Bucket': 'bucket', 'Key': 'key', 'VersionId': 'id'}." 

417 " Note that the VersionId key is optional and may be omitted." 

418 " To specify an S3 access point, provide the access point" 

419 " ARN for the ``Bucket`` key in the copy source dictionary. If you" 

420 " want to provide the copy source for an S3 access point as a" 

421 " string instead of a dictionary, the ARN provided must be the" 

422 " full S3 access point object ARN" 

423 " (i.e. {accesspoint_arn}/object/{key})" 

424 ) 

425 

426 

427def handle_copy_source_param(params, **kwargs): 

428 """Convert CopySource param for CopyObject/UploadPartCopy. 

429 

430 This handler will deal with two cases: 

431 

432 * CopySource provided as a string. We'll make a best effort 

433 to URL encode the key name as required. This will require 

434 parsing the bucket and version id from the CopySource value 

435 and only encoding the key. 

436 * CopySource provided as a dict. In this case we're 

437 explicitly given the Bucket, Key, and VersionId so we're 

438 able to encode the key and ensure this value is serialized 

439 and correctly sent to S3. 

440 

441 """ 

442 source = params.get('CopySource') 

443 if source is None: 

444 # The call will eventually fail but we'll let the 

445 # param validator take care of this. It will 

446 # give a better error message. 

447 return 

448 if isinstance(source, str): 

449 params['CopySource'] = _quote_source_header(source) 

450 elif isinstance(source, dict): 

451 params['CopySource'] = _quote_source_header_from_dict(source) 

452 

453 

454def _quote_source_header_from_dict(source_dict): 

455 try: 

456 bucket = source_dict['Bucket'] 

457 key = source_dict['Key'] 

458 version_id = source_dict.get('VersionId') 

459 if VALID_S3_ARN.search(bucket): 

460 final = f'{bucket}/object/{key}' 

461 else: 

462 final = f'{bucket}/{key}' 

463 except KeyError as e: 

464 raise ParamValidationError( 

465 report=f'Missing required parameter: {str(e)}' 

466 ) 

467 final = percent_encode(final, safe=SAFE_CHARS + '/') 

468 if version_id is not None: 

469 final += f'?versionId={version_id}' 

470 return final 

471 

472 

473def _quote_source_header(value): 

474 result = VERSION_ID_SUFFIX.search(value) 

475 if result is None: 

476 return percent_encode(value, safe=SAFE_CHARS + '/') 

477 else: 

478 first, version_id = value[: result.start()], value[result.start() :] 

479 return percent_encode(first, safe=SAFE_CHARS + '/') + version_id 

480 

481 

482def _get_cross_region_presigned_url( 

483 request_signer, request_dict, model, source_region, destination_region 

484): 

485 # The better way to do this is to actually get the 

486 # endpoint_resolver and get the endpoint_url given the 

487 # source region. In this specific case, we know that 

488 # we can safely replace the dest region with the source 

489 # region because of the supported EC2 regions, but in 

490 # general this is not a safe assumption to make. 

491 # I think eventually we should try to plumb through something 

492 # that allows us to resolve endpoints from regions. 

493 request_dict_copy = copy.deepcopy(request_dict) 

494 request_dict_copy['body']['DestinationRegion'] = destination_region 

495 request_dict_copy['url'] = request_dict['url'].replace( 

496 destination_region, source_region 

497 ) 

498 request_dict_copy['method'] = 'GET' 

499 request_dict_copy['headers'] = {} 

500 return request_signer.generate_presigned_url( 

501 request_dict_copy, region_name=source_region, operation_name=model.name 

502 ) 

503 

504 

505def _get_presigned_url_source_and_destination_regions(request_signer, params): 

506 # Gets the source and destination regions to be used 

507 destination_region = request_signer._region_name 

508 source_region = params.get('SourceRegion') 

509 return source_region, destination_region 

510 

511 

512def inject_presigned_url_ec2(params, request_signer, model, **kwargs): 

513 # The customer can still provide this, so we should pass if they do. 

514 if 'PresignedUrl' in params['body']: 

515 return 

516 src, dest = _get_presigned_url_source_and_destination_regions( 

517 request_signer, params['body'] 

518 ) 

519 url = _get_cross_region_presigned_url( 

520 request_signer, params, model, src, dest 

521 ) 

522 params['body']['PresignedUrl'] = url 

523 # EC2 Requires that the destination region be sent over the wire in 

524 # addition to the source region. 

525 params['body']['DestinationRegion'] = dest 

526 

527 

528def inject_presigned_url_rds(params, request_signer, model, **kwargs): 

529 # SourceRegion is not required for RDS operations, so it's possible that 

530 # it isn't set. In that case it's probably a local copy so we don't need 

531 # to do anything else. 

532 if 'SourceRegion' not in params['body']: 

533 return 

534 

535 src, dest = _get_presigned_url_source_and_destination_regions( 

536 request_signer, params['body'] 

537 ) 

538 

539 # Since SourceRegion isn't actually modeled for RDS, it needs to be 

540 # removed from the request params before we send the actual request. 

541 del params['body']['SourceRegion'] 

542 

543 if 'PreSignedUrl' in params['body']: 

544 return 

545 

546 url = _get_cross_region_presigned_url( 

547 request_signer, params, model, src, dest 

548 ) 

549 params['body']['PreSignedUrl'] = url 

550 

551 

552def json_decode_policies(parsed, model, **kwargs): 

553 # Any time an IAM operation returns a policy document 

554 # it is a string that is json that has been urlencoded, 

555 # i.e urlencode(json.dumps(policy_document)). 

556 # To give users something more useful, we will urldecode 

557 # this value and json.loads() the result so that they have 

558 # the policy document as a dictionary. 

559 output_shape = model.output_shape 

560 if output_shape is not None: 

561 _decode_policy_types(parsed, model.output_shape) 

562 

563 

564def _decode_policy_types(parsed, shape): 

565 # IAM consistently uses the policyDocumentType shape to indicate 

566 # strings that have policy documents. 

567 shape_name = 'policyDocumentType' 

568 if shape.type_name == 'structure': 

569 for member_name, member_shape in shape.members.items(): 

570 if ( 

571 member_shape.type_name == 'string' 

572 and member_shape.name == shape_name 

573 and member_name in parsed 

574 ): 

575 parsed[member_name] = decode_quoted_jsondoc( 

576 parsed[member_name] 

577 ) 

578 elif member_name in parsed: 

579 _decode_policy_types(parsed[member_name], member_shape) 

580 if shape.type_name == 'list': 

581 shape_member = shape.member 

582 for item in parsed: 

583 _decode_policy_types(item, shape_member) 

584 

585 

586def parse_get_bucket_location(parsed, http_response, **kwargs): 

587 # s3.GetBucketLocation cannot be modeled properly. To 

588 # account for this we just manually parse the XML document. 

589 # The "parsed" passed in only has the ResponseMetadata 

590 # filled out. This handler will fill in the LocationConstraint 

591 # value. 

592 if http_response.raw is None: 

593 return 

594 response_body = http_response.content 

595 parser = ETree.XMLParser(target=ETree.TreeBuilder(), encoding='utf-8') 

596 parser.feed(response_body) 

597 root = parser.close() 

598 region = root.text 

599 parsed['LocationConstraint'] = region 

600 

601 

602def base64_encode_user_data(params, **kwargs): 

603 if 'UserData' in params: 

604 if isinstance(params['UserData'], str): 

605 # Encode it to bytes if it is text. 

606 params['UserData'] = params['UserData'].encode('utf-8') 

607 params['UserData'] = base64.b64encode(params['UserData']).decode( 

608 'utf-8' 

609 ) 

610 

611 

612def document_base64_encoding(param): 

613 description = ( 

614 '**This value will be base64 encoded automatically. Do ' 

615 'not base64 encode this value prior to performing the ' 

616 'operation.**' 

617 ) 

618 append = AppendParamDocumentation(param, description) 

619 return append.append_documentation 

620 

621 

622def validate_ascii_metadata(params, **kwargs): 

623 """Verify S3 Metadata only contains ascii characters. 

624 

625 From: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html 

626 

627 "Amazon S3 stores user-defined metadata in lowercase. Each name, value pair 

628 must conform to US-ASCII when using REST and UTF-8 when using SOAP or 

629 browser-based uploads via POST." 

630 

631 """ 

632 metadata = params.get('Metadata') 

633 if not metadata or not isinstance(metadata, dict): 

634 # We have to at least type check the metadata as a dict type 

635 # because this handler is called before param validation. 

636 # We'll go ahead and return because the param validator will 

637 # give a descriptive error message for us. 

638 # We might need a post-param validation event. 

639 return 

640 for key, value in metadata.items(): 

641 try: 

642 key.encode('ascii') 

643 value.encode('ascii') 

644 except UnicodeEncodeError: 

645 error_msg = ( 

646 'Non ascii characters found in S3 metadata ' 

647 f'for key "{key}", value: "{value}". \nS3 metadata can only ' 

648 'contain ASCII characters. ' 

649 ) 

650 raise ParamValidationError(report=error_msg) 

651 

652 

653def fix_route53_ids(params, model, **kwargs): 

654 """ 

655 Check for and split apart Route53 resource IDs, setting 

656 only the last piece. This allows the output of one operation 

657 (e.g. ``'foo/1234'``) to be used as input in another 

658 operation (e.g. it expects just ``'1234'``). 

659 """ 

660 input_shape = model.input_shape 

661 if not input_shape or not hasattr(input_shape, 'members'): 

662 return 

663 

664 members = [ 

665 name 

666 for (name, shape) in input_shape.members.items() 

667 if shape.name in ['ResourceId', 'DelegationSetId', 'ChangeId'] 

668 ] 

669 

670 for name in members: 

671 if name in params: 

672 orig_value = params[name] 

673 params[name] = orig_value.split('/')[-1] 

674 logger.debug('%s %s -> %s', name, orig_value, params[name]) 

675 

676 

677def inject_account_id(params, **kwargs): 

678 if params.get('accountId') is None: 

679 # Glacier requires accountId, but allows you 

680 # to specify '-' for the current owners account. 

681 # We add this default value if the user does not 

682 # provide the accountId as a convenience. 

683 params['accountId'] = '-' 

684 

685 

686def add_glacier_version(model, params, **kwargs): 

687 request_dict = params 

688 request_dict['headers']['x-amz-glacier-version'] = model.metadata[ 

689 'apiVersion' 

690 ] 

691 

692 

693def add_accept_header(model, params, **kwargs): 

694 if params['headers'].get('Accept', None) is None: 

695 request_dict = params 

696 request_dict['headers']['Accept'] = 'application/json' 

697 

698 

699def add_glacier_checksums(params, **kwargs): 

700 """Add glacier checksums to the http request. 

701 

702 This will add two headers to the http request: 

703 

704 * x-amz-content-sha256 

705 * x-amz-sha256-tree-hash 

706 

707 These values will only be added if they are not present 

708 in the HTTP request. 

709 

710 """ 

711 request_dict = params 

712 headers = request_dict['headers'] 

713 body = request_dict['body'] 

714 if isinstance(body, bytes): 

715 # If the user provided a bytes type instead of a file 

716 # like object, we're temporarily create a BytesIO object 

717 # so we can use the util functions to calculate the 

718 # checksums which assume file like objects. Note that 

719 # we're not actually changing the body in the request_dict. 

720 body = BytesIO(body) 

721 starting_position = body.tell() 

722 if 'x-amz-content-sha256' not in headers: 

723 headers['x-amz-content-sha256'] = utils.calculate_sha256( 

724 body, as_hex=True 

725 ) 

726 body.seek(starting_position) 

727 if 'x-amz-sha256-tree-hash' not in headers: 

728 headers['x-amz-sha256-tree-hash'] = utils.calculate_tree_hash(body) 

729 body.seek(starting_position) 

730 

731 

732def document_glacier_tree_hash_checksum(): 

733 doc = ''' 

734 This is a required field. 

735 

736 Ideally you will want to compute this value with checksums from 

737 previous uploaded parts, using the algorithm described in 

738 `Glacier documentation <http://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html>`_. 

739 

740 But if you prefer, you can also use botocore.utils.calculate_tree_hash() 

741 to compute it from raw file by:: 

742 

743 checksum = calculate_tree_hash(open('your_file.txt', 'rb')) 

744 

745 ''' 

746 return AppendParamDocumentation('checksum', doc).append_documentation 

747 

748 

749def document_cloudformation_get_template_return_type( 

750 section, event_name, **kwargs 

751): 

752 if 'response-params' in event_name: 

753 template_body_section = section.get_section('TemplateBody') 

754 type_section = template_body_section.get_section('param-type') 

755 type_section.clear_text() 

756 type_section.write('(*dict*) --') 

757 elif 'response-example' in event_name: 

758 parent = section.get_section('structure-value') 

759 param_line = parent.get_section('TemplateBody') 

760 value_portion = param_line.get_section('member-value') 

761 value_portion.clear_text() 

762 value_portion.write('{}') 

763 

764 

765def switch_host_machinelearning(request, **kwargs): 

766 switch_host_with_param(request, 'PredictEndpoint') 

767 

768 

769def check_openssl_supports_tls_version_1_2(**kwargs): 

770 import ssl 

771 

772 try: 

773 openssl_version_tuple = ssl.OPENSSL_VERSION_INFO 

774 if openssl_version_tuple < (1, 0, 1): 

775 warnings.warn( 

776 f'Currently installed openssl version: {ssl.OPENSSL_VERSION} does not ' 

777 'support TLS 1.2, which is required for use of iot-data. ' 

778 'Please use python installed with openssl version 1.0.1 or ' 

779 'higher.', 

780 UnsupportedTLSVersionWarning, 

781 ) 

782 # We cannot check the openssl version on python2.6, so we should just 

783 # pass on this conveniency check. 

784 except AttributeError: 

785 pass 

786 

787 

788def change_get_to_post(request, **kwargs): 

789 # This is useful when we need to change a potentially large GET request 

790 # into a POST with x-www-form-urlencoded encoding. 

791 if request.method == 'GET' and '?' in request.url: 

792 request.headers['Content-Type'] = 'application/x-www-form-urlencoded' 

793 request.method = 'POST' 

794 request.url, request.data = request.url.split('?', 1) 

795 

796 

797def set_list_objects_encoding_type_url(params, context, **kwargs): 

798 if 'EncodingType' not in params: 

799 # We set this context so that we know it wasn't the customer that 

800 # requested the encoding. 

801 context['encoding_type_auto_set'] = True 

802 params['EncodingType'] = 'url' 

803 

804 

805def decode_list_object(parsed, context, **kwargs): 

806 # This is needed because we are passing url as the encoding type. Since the 

807 # paginator is based on the key, we need to handle it before it can be 

808 # round tripped. 

809 # 

810 # From the documentation: If you specify encoding-type request parameter, 

811 # Amazon S3 includes this element in the response, and returns encoded key 

812 # name values in the following response elements: 

813 # Delimiter, Marker, Prefix, NextMarker, Key. 

814 _decode_list_object( 

815 top_level_keys=['Delimiter', 'Marker', 'NextMarker'], 

816 nested_keys=[('Contents', 'Key'), ('CommonPrefixes', 'Prefix')], 

817 parsed=parsed, 

818 context=context, 

819 ) 

820 

821 

822def decode_list_object_v2(parsed, context, **kwargs): 

823 # From the documentation: If you specify encoding-type request parameter, 

824 # Amazon S3 includes this element in the response, and returns encoded key 

825 # name values in the following response elements: 

826 # Delimiter, Prefix, ContinuationToken, Key, and StartAfter. 

827 _decode_list_object( 

828 top_level_keys=['Delimiter', 'Prefix', 'StartAfter'], 

829 nested_keys=[('Contents', 'Key'), ('CommonPrefixes', 'Prefix')], 

830 parsed=parsed, 

831 context=context, 

832 ) 

833 

834 

835def decode_list_object_versions(parsed, context, **kwargs): 

836 # From the documentation: If you specify encoding-type request parameter, 

837 # Amazon S3 includes this element in the response, and returns encoded key 

838 # name values in the following response elements: 

839 # KeyMarker, NextKeyMarker, Prefix, Key, and Delimiter. 

840 _decode_list_object( 

841 top_level_keys=[ 

842 'KeyMarker', 

843 'NextKeyMarker', 

844 'Prefix', 

845 'Delimiter', 

846 ], 

847 nested_keys=[ 

848 ('Versions', 'Key'), 

849 ('DeleteMarkers', 'Key'), 

850 ('CommonPrefixes', 'Prefix'), 

851 ], 

852 parsed=parsed, 

853 context=context, 

854 ) 

855 

856 

857def _decode_list_object(top_level_keys, nested_keys, parsed, context): 

858 if parsed.get('EncodingType') == 'url' and context.get( 

859 'encoding_type_auto_set' 

860 ): 

861 # URL decode top-level keys in the response if present. 

862 for key in top_level_keys: 

863 if key in parsed: 

864 parsed[key] = unquote_str(parsed[key]) 

865 # URL decode nested keys from the response if present. 

866 for top_key, child_key in nested_keys: 

867 if top_key in parsed: 

868 for member in parsed[top_key]: 

869 member[child_key] = unquote_str(member[child_key]) 

870 

871 

872def convert_body_to_file_like_object(params, **kwargs): 

873 if 'Body' in params: 

874 if isinstance(params['Body'], str): 

875 params['Body'] = BytesIO(ensure_bytes(params['Body'])) 

876 elif isinstance(params['Body'], bytes): 

877 params['Body'] = BytesIO(params['Body']) 

878 

879 

880def _add_parameter_aliases(handler_list): 

881 # Mapping of original parameter to parameter alias. 

882 # The key is <service>.<operation>.parameter 

883 # The first part of the key is used for event registration. 

884 # The last part is the original parameter name and the value is the 

885 # alias to expose in documentation. 

886 aliases = { 

887 'ec2.*.Filter': 'Filters', 

888 'logs.CreateExportTask.from': 'fromTime', 

889 'cloudsearchdomain.Search.return': 'returnFields', 

890 } 

891 

892 for original, new_name in aliases.items(): 

893 event_portion, original_name = original.rsplit('.', 1) 

894 parameter_alias = ParameterAlias(original_name, new_name) 

895 

896 # Add the handlers to the list of handlers. 

897 # One handler is to handle when users provide the alias. 

898 # The other handler is to update the documentation to show only 

899 # the alias. 

900 parameter_build_event_handler_tuple = ( 

901 'before-parameter-build.' + event_portion, 

902 parameter_alias.alias_parameter_in_call, 

903 REGISTER_FIRST, 

904 ) 

905 docs_event_handler_tuple = ( 

906 'docs.*.' + event_portion + '.complete-section', 

907 parameter_alias.alias_parameter_in_documentation, 

908 ) 

909 handler_list.append(parameter_build_event_handler_tuple) 

910 handler_list.append(docs_event_handler_tuple) 

911 

912 

913class ParameterAlias: 

914 def __init__(self, original_name, alias_name): 

915 self._original_name = original_name 

916 self._alias_name = alias_name 

917 

918 def alias_parameter_in_call(self, params, model, **kwargs): 

919 if model.input_shape: 

920 # Only consider accepting the alias if it is modeled in the 

921 # input shape. 

922 if self._original_name in model.input_shape.members: 

923 if self._alias_name in params: 

924 if self._original_name in params: 

925 raise AliasConflictParameterError(