Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/botocore/client.py: 21%

1# Copyright 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. 

13import logging 

14 

15from botocore import waiter, xform_name 

16from botocore.args import ClientArgsCreator 

17from botocore.auth import AUTH_TYPE_MAPS, resolve_auth_type 

18from botocore.awsrequest import prepare_request_dict 

19from botocore.compress import maybe_compress_request 

20from botocore.config import Config 

21from botocore.credentials import RefreshableCredentials 

22from botocore.discovery import ( 

23 EndpointDiscoveryHandler, 

24 EndpointDiscoveryManager, 

25 block_endpoint_discovery_required_operations, 

26) 

27from botocore.docs.docstring import ClientMethodDocstring, PaginatorDocstring 

28from botocore.exceptions import ( 

29 DataNotFoundError, 

30 InvalidEndpointDiscoveryConfigurationError, 

31 OperationNotPageableError, 

32 UnknownServiceError, 

33 UnknownSignatureVersionError, 

34) 

35from botocore.history import get_global_history_recorder 

36from botocore.hooks import first_non_none_response 

37from botocore.httpchecksum import ( 

38 apply_request_checksum, 

39 resolve_checksum_context, 

40) 

41from botocore.model import ServiceModel 

42from botocore.paginate import Paginator 

43from botocore.retries import adaptive, standard 

44from botocore.useragent import UserAgentString 

45from botocore.utils import ( 

46 CachedProperty, 

47 EventbridgeSignerSetter, 

48 S3ControlArnParamHandlerv2, 

49 S3ExpressIdentityResolver, 

50 S3RegionRedirectorv2, 

51 ensure_boolean, 

52 get_service_module_name, 

53) 

54 

55# Keep these imported. There's pre-existing code that uses: 

56# "from botocore.client import UNSIGNED" 

57# "from botocore.client import ClientError" 

58# etc. 

59from botocore.exceptions import ClientError # noqa 

60from botocore.utils import S3ArnParamHandler # noqa 

61from botocore.utils import S3ControlArnParamHandler # noqa 

62from botocore.utils import S3ControlEndpointSetter # noqa 

63from botocore.utils import S3EndpointSetter # noqa 

64from botocore.utils import S3RegionRedirector # noqa 

65from botocore import UNSIGNED # noqa 

66 

67 

68_LEGACY_SIGNATURE_VERSIONS = frozenset( 

69 ( 

70 'v2', 

71 'v3', 

72 'v3https', 

73 'v4', 

74 's3', 

75 's3v4', 

76 ) 

77) 

78 

79 

80logger = logging.getLogger(__name__) 

81history_recorder = get_global_history_recorder() 

82 

83 

84class ClientCreator: 

85 """Creates client objects for a service.""" 

86 

87 def __init__( 

88 self, 

89 loader, 

90 endpoint_resolver, 

91 user_agent, 

92 event_emitter, 

93 retry_handler_factory, 

94 retry_config_translator, 

95 response_parser_factory=None, 

96 exceptions_factory=None, 

97 config_store=None, 

98 user_agent_creator=None, 

99 ): 

100 self._loader = loader 

101 self._endpoint_resolver = endpoint_resolver 

102 self._user_agent = user_agent 

103 self._event_emitter = event_emitter 

104 self._retry_handler_factory = retry_handler_factory 

105 self._retry_config_translator = retry_config_translator 

106 self._response_parser_factory = response_parser_factory 

107 self._exceptions_factory = exceptions_factory 

108 # TODO: Migrate things away from scoped_config in favor of the 

109 # config_store. The config store can pull things from both the scoped 

110 # config and environment variables (and potentially more in the 

111 # future). 

112 self._config_store = config_store 

113 self._user_agent_creator = user_agent_creator 

114 

115 def create_client( 

116 self, 

117 service_name, 

118 region_name, 

119 is_secure=True, 

120 endpoint_url=None, 

121 verify=None, 

122 credentials=None, 

123 scoped_config=None, 

124 api_version=None, 

125 client_config=None, 

126 auth_token=None, 

127 ): 

128 responses = self._event_emitter.emit( 

129 'choose-service-name', service_name=service_name 

130 ) 

131 service_name = first_non_none_response(responses, default=service_name) 

132 service_model = self._load_service_model(service_name, api_version) 

133 try: 

134 endpoints_ruleset_data = self._load_service_endpoints_ruleset( 

135 service_name, api_version 

136 ) 

137 partition_data = self._loader.load_data('partitions') 

138 except UnknownServiceError: 

139 endpoints_ruleset_data = None 

140 partition_data = None 

141 logger.info( 

142 'No endpoints ruleset found for service %s, falling back to ' 

143 'legacy endpoint routing.', 

144 service_name, 

145 ) 

146 

147 cls = self._create_client_class(service_name, service_model) 

148 region_name, client_config = self._normalize_fips_region( 

149 region_name, client_config 

150 ) 

151 if auth := service_model.metadata.get('auth'): 

152 service_signature_version = resolve_auth_type(auth) 

153 else: 

154 service_signature_version = service_model.metadata.get( 

155 'signatureVersion' 

156 ) 

157 endpoint_bridge = ClientEndpointBridge( 

158 self._endpoint_resolver, 

159 scoped_config, 

160 client_config, 

161 service_signing_name=service_model.metadata.get('signingName'), 

162 config_store=self._config_store, 

163 service_signature_version=service_signature_version, 

164 ) 

165 client_args = self._get_client_args( 

166 service_model, 

167 region_name, 

168 is_secure, 

169 endpoint_url, 

170 verify, 

171 credentials, 

172 scoped_config, 

173 client_config, 

174 endpoint_bridge, 

175 auth_token, 

176 endpoints_ruleset_data, 

177 partition_data, 

178 ) 

179 service_client = cls(**client_args) 

180 self._register_retries(service_client) 

181 self._register_s3_events( 

182 client=service_client, 

183 endpoint_bridge=None, 

184 endpoint_url=None, 

185 client_config=client_config, 

186 scoped_config=scoped_config, 

187 ) 

188 self._register_s3express_events(client=service_client) 

189 self._register_s3_control_events(client=service_client) 

190 self._register_endpoint_discovery( 

191 service_client, endpoint_url, client_config 

192 ) 

193 return service_client 

194 

195 def create_client_class(self, service_name, api_version=None): 

196 service_model = self._load_service_model(service_name, api_version) 

197 return self._create_client_class(service_name, service_model) 

198 

199 def _create_client_class(self, service_name, service_model): 

200 class_attributes = self._create_methods(service_model) 

201 py_name_to_operation_name = self._create_name_mapping(service_model) 

202 class_attributes['_PY_TO_OP_NAME'] = py_name_to_operation_name 

203 bases = [BaseClient] 

204 service_id = service_model.service_id.hyphenize() 

205 self._event_emitter.emit( 

206 f'creating-client-class.{service_id}', 

207 class_attributes=class_attributes, 

208 base_classes=bases, 

209 ) 

210 class_name = get_service_module_name(service_model) 

211 cls = type(str(class_name), tuple(bases), class_attributes) 

212 return cls 

213 

214 def _normalize_fips_region(self, region_name, client_config): 

215 if region_name is not None: 

216 normalized_region_name = region_name.replace('fips-', '').replace( 

217 '-fips', '' 

218 ) 

219 # If region has been transformed then set flag 

220 if normalized_region_name != region_name: 

221 config_use_fips_endpoint = Config(use_fips_endpoint=True) 

222 if client_config: 

223 # Keeping endpoint setting client specific 

224 client_config = client_config.merge( 

225 config_use_fips_endpoint 

226 ) 

227 else: 

228 client_config = config_use_fips_endpoint 

229 logger.warning( 

230 f'transforming region from {region_name} to ' 

231 f'{normalized_region_name} and setting ' 

232 'use_fips_endpoint to true. client should not ' 

233 'be configured with a fips psuedo region.' 

234 ) 

235 region_name = normalized_region_name 

236 return region_name, client_config 

237 

238 def _load_service_model(self, service_name, api_version=None): 

239 json_model = self._loader.load_service_model( 

240 service_name, 'service-2', api_version=api_version 

241 ) 

242 service_model = ServiceModel(json_model, service_name=service_name) 

243 return service_model 

244 

245 def _load_service_endpoints_ruleset(self, service_name, api_version=None): 

246 return self._loader.load_service_model( 

247 service_name, 'endpoint-rule-set-1', api_version=api_version 

248 ) 

249 

250 def _register_retries(self, client): 

251 retry_mode = client.meta.config.retries['mode'] 

252 if retry_mode == 'standard': 

253 self._register_v2_standard_retries(client) 

254 elif retry_mode == 'adaptive': 

255 self._register_v2_standard_retries(client) 

256 self._register_v2_adaptive_retries(client) 

257 elif retry_mode == 'legacy': 

258 self._register_legacy_retries(client) 

259 

260 def _register_v2_standard_retries(self, client): 

261 max_attempts = client.meta.config.retries.get('total_max_attempts') 

262 kwargs = {'client': client} 

263 if max_attempts is not None: 

264 kwargs['max_attempts'] = max_attempts 

265 standard.register_retry_handler(**kwargs) 

266 

267 def _register_v2_adaptive_retries(self, client): 

268 adaptive.register_retry_handler(client) 

269 

270 def _register_legacy_retries(self, client): 

271 endpoint_prefix = client.meta.service_model.endpoint_prefix 

272 service_id = client.meta.service_model.service_id 

273 service_event_name = service_id.hyphenize() 

274 

275 # First, we load the entire retry config for all services, 

276 # then pull out just the information we need. 

277 original_config = self._loader.load_data('_retry') 

278 if not original_config: 

279 return 

280 

281 retries = self._transform_legacy_retries(client.meta.config.retries) 

282 retry_config = self._retry_config_translator.build_retry_config( 

283 endpoint_prefix, 

284 original_config.get('retry', {}), 

285 original_config.get('definitions', {}), 

286 retries, 

287 ) 

288 

289 logger.debug( 

290 "Registering retry handlers for service: %s", 

291 client.meta.service_model.service_name, 

292 ) 

293 handler = self._retry_handler_factory.create_retry_handler( 

294 retry_config, endpoint_prefix 

295 ) 

296 unique_id = f'retry-config-{service_event_name}' 

297 client.meta.events.register( 

298 f"needs-retry.{service_event_name}", handler, unique_id=unique_id 

299 ) 

300 

301 def _transform_legacy_retries(self, retries): 

302 if retries is None: 

303 return 

304 copied_args = retries.copy() 

305 if 'total_max_attempts' in retries: 

306 copied_args = retries.copy() 

307 copied_args['max_attempts'] = ( 

308 copied_args.pop('total_max_attempts') - 1 

309 ) 

310 return copied_args 

311 

312 def _get_retry_mode(self, client, config_store): 

313 client_retries = client.meta.config.retries 

314 if ( 

315 client_retries is not None 

316 and client_retries.get('mode') is not None 

317 ): 

318 return client_retries['mode'] 

319 return config_store.get_config_variable('retry_mode') or 'legacy' 

320 

321 def _register_endpoint_discovery(self, client, endpoint_url, config): 

322 if endpoint_url is not None: 

323 # Don't register any handlers in the case of a custom endpoint url 

324 return 

325 # Only attach handlers if the service supports discovery 

326 if client.meta.service_model.endpoint_discovery_operation is None: 

327 return 

328 events = client.meta.events 

329 service_id = client.meta.service_model.service_id.hyphenize() 

330 enabled = False 

331 if config and config.endpoint_discovery_enabled is not None: 

332 enabled = config.endpoint_discovery_enabled 

333 elif self._config_store: 

334 enabled = self._config_store.get_config_variable( 

335 'endpoint_discovery_enabled' 

336 ) 

337 

338 enabled = self._normalize_endpoint_discovery_config(enabled) 

339 if enabled and self._requires_endpoint_discovery(client, enabled): 

340 discover = enabled is True 

341 manager = EndpointDiscoveryManager( 

342 client, always_discover=discover 

343 ) 

344 handler = EndpointDiscoveryHandler(manager) 

345 handler.register(events, service_id) 

346 else: 

347 events.register( 

348 'before-parameter-build', 

349 block_endpoint_discovery_required_operations, 

350 ) 

351 

352 def _normalize_endpoint_discovery_config(self, enabled): 

353 """Config must either be a boolean-string or string-literal 'auto'""" 

354 if isinstance(enabled, str): 

355 enabled = enabled.lower().strip() 

356 if enabled == 'auto': 

357 return enabled 

358 elif enabled in ('true', 'false'): 

359 return ensure_boolean(enabled) 

360 elif isinstance(enabled, bool): 

361 return enabled 

362 

363 raise InvalidEndpointDiscoveryConfigurationError(config_value=enabled) 

364 

365 def _requires_endpoint_discovery(self, client, enabled): 

366 if enabled == "auto": 

367 return client.meta.service_model.endpoint_discovery_required 

368 return enabled 

369 

370 def _register_eventbridge_events( 

371 self, client, endpoint_bridge, endpoint_url 

372 ): 

373 if client.meta.service_model.service_name != 'events': 

374 return 

375 EventbridgeSignerSetter( 

376 endpoint_resolver=self._endpoint_resolver, 

377 region=client.meta.region_name, 

378 endpoint_url=endpoint_url, 

379 ).register(client.meta.events) 

380 

381 def _register_s3express_events( 

382 self, 

383 client, 

384 endpoint_bridge=None, 

385 endpoint_url=None, 

386 client_config=None, 

387 scoped_config=None, 

388 ): 

389 if client.meta.service_model.service_name != 's3': 

390 return 

391 S3ExpressIdentityResolver(client, RefreshableCredentials).register() 

392 

393 def _register_s3_events( 

394 self, 

395 client, 

396 endpoint_bridge, 

397 endpoint_url, 

398 client_config, 

399 scoped_config, 

400 ): 

401 if client.meta.service_model.service_name != 's3': 

402 return 

403 S3RegionRedirectorv2(None, client).register() 

404 self._set_s3_presign_signature_version( 

405 client.meta, client_config, scoped_config 

406 ) 

407 client.meta.events.register( 

408 'before-parameter-build.s3', self._inject_s3_input_parameters 

409 ) 

410 

411 def _register_s3_control_events( 

412 self, 

413 client, 

414 endpoint_bridge=None, 

415 endpoint_url=None, 

416 client_config=None, 

417 scoped_config=None, 

418 ): 

419 if client.meta.service_model.service_name != 's3control': 

420 return 

421 S3ControlArnParamHandlerv2().register(client.meta.events) 

422 

423 def _set_s3_presign_signature_version( 

424 self, client_meta, client_config, scoped_config 

425 ): 

426 # This will return the manually configured signature version, or None 

427 # if none was manually set. If a customer manually sets the signature 

428 # version, we always want to use what they set. 

429 provided_signature_version = _get_configured_signature_version( 

430 's3', client_config, scoped_config 

431 ) 

432 if provided_signature_version is not None: 

433 return 

434 

435 # Check to see if the region is a region that we know about. If we 

436 # don't know about a region, then we can safely assume it's a new 

437 # region that is sigv4 only, since all new S3 regions only allow sigv4. 

438 # The only exception is aws-global. This is a pseudo-region for the 

439 # global endpoint, we should respect the signature versions it 

440 # supports, which includes v2. 

441 regions = self._endpoint_resolver.get_available_endpoints( 

442 's3', client_meta.partition 

443 ) 

444 if ( 

445 client_meta.region_name != 'aws-global' 

446 and client_meta.region_name not in regions 

447 ): 

448 return 

449 

450 # If it is a region we know about, we want to default to sigv2, so here 

451 # we check to see if it is available. 

452 endpoint = self._endpoint_resolver.construct_endpoint( 

453 's3', client_meta.region_name 

454 ) 

455 signature_versions = endpoint['signatureVersions'] 

456 if 's3' not in signature_versions: 

457 return 

458 

459 # We now know that we're in a known region that supports sigv2 and 

460 # the customer hasn't set a signature version so we default the 

461 # signature version to sigv2. 

462 client_meta.events.register( 

463 'choose-signer.s3', self._default_s3_presign_to_sigv2 

464 ) 

465 

466 def _inject_s3_input_parameters(self, params, context, **kwargs): 

467 context['input_params'] = {} 

468 inject_parameters = ('Bucket', 'Delete', 'Key', 'Prefix') 

469 for inject_parameter in inject_parameters: 

470 if inject_parameter in params: 

471 context['input_params'][inject_parameter] = params[ 

472 inject_parameter 

473 ] 

474 

475 def _default_s3_presign_to_sigv2(self, signature_version, **kwargs): 

476 """ 

477 Returns the 's3' (sigv2) signer if presigning an s3 request. This is 

478 intended to be used to set the default signature version for the signer 

479 to sigv2. Situations where an asymmetric signature is required are the 

480 exception, for example MRAP needs v4a. 

481 

482 :type signature_version: str 

483 :param signature_version: The current client signature version. 

484 

485 :type signing_name: str 

486 :param signing_name: The signing name of the service. 

487 

488 :return: 's3' if the request is an s3 presign request, None otherwise 

489 """ 

490 if signature_version.startswith('v4a'): 

491 return 

492 

493 if signature_version.startswith('v4-s3express'): 

494 return signature_version 

495 

496 for suffix in ['-query', '-presign-post']: 

497 if signature_version.endswith(suffix): 

498 return f's3{suffix}' 

499 

500 def _get_client_args( 

501 self, 

502 service_model, 

503 region_name, 

504 is_secure, 

505 endpoint_url, 

506 verify, 

507 credentials, 

508 scoped_config, 

509 client_config, 

510 endpoint_bridge, 

511 auth_token, 

512 endpoints_ruleset_data, 

513 partition_data, 

514 ): 

515 args_creator = ClientArgsCreator( 

516 self._event_emitter, 

517 self._user_agent, 

518 self._response_parser_factory, 

519 self._loader, 

520 self._exceptions_factory, 

521 config_store=self._config_store, 

522 user_agent_creator=self._user_agent_creator, 

523 ) 

524 return args_creator.get_client_args( 

525 service_model, 

526 region_name, 

527 is_secure, 

528 endpoint_url, 

529 verify, 

530 credentials, 

531 scoped_config, 

532 client_config, 

533 endpoint_bridge, 

534 auth_token, 

535 endpoints_ruleset_data, 

536 partition_data, 

537 ) 

538 

539 def _create_methods(self, service_model): 

540 op_dict = {} 

541 for operation_name in service_model.operation_names: 

542 py_operation_name = xform_name(operation_name) 

543 op_dict[py_operation_name] = self._create_api_method( 

544 py_operation_name, operation_name, service_model 

545 ) 

546 return op_dict 

547 

548 def _create_name_mapping(self, service_model): 

549 # py_name -> OperationName, for every operation available 

550 # for a service. 

551 mapping = {} 

552 for operation_name in service_model.operation_names: 

553 py_operation_name = xform_name(operation_name) 

554 mapping[py_operation_name] = operation_name 

555 return mapping 

556 

557 def _create_api_method( 

558 self, py_operation_name, operation_name, service_model 

559 ): 

560 def _api_call(self, *args, **kwargs): 

561 # We're accepting *args so that we can give a more helpful 

562 # error message than TypeError: _api_call takes exactly 

563 # 1 argument. 

564 if args: 

565 raise TypeError( 

566 f"{py_operation_name}() only accepts keyword arguments." 

567 ) 

568 # The "self" in this scope is referring to the BaseClient. 

569 return self._make_api_call(operation_name, kwargs) 

570 

571 _api_call.__name__ = str(py_operation_name) 

572 

573 # Add the docstring to the client method 

574 operation_model = service_model.operation_model(operation_name) 

575 docstring = ClientMethodDocstring( 

576 operation_model=operation_model, 

577 method_name=operation_name, 

578 event_emitter=self._event_emitter, 

579 method_description=operation_model.documentation, 

580 example_prefix=f'response = client.{py_operation_name}', 

581 include_signature=False, 

582 ) 

583 _api_call.__doc__ = docstring 

584 return _api_call 

585 

586 

587class ClientEndpointBridge: 

588 """Bridges endpoint data and client creation 

589 

590 This class handles taking out the relevant arguments from the endpoint 

591 resolver and determining which values to use, taking into account any 

592 client configuration options and scope configuration options. 

593 

594 This class also handles determining what, if any, region to use if no 

595 explicit region setting is provided. For example, Amazon S3 client will 

596 utilize "us-east-1" by default if no region can be resolved.""" 

597 

598 DEFAULT_ENDPOINT = '{service}.{region}.amazonaws.com' 

599 _DUALSTACK_CUSTOMIZED_SERVICES = ['s3', 's3-control'] 

600 

601 def __init__( 

602 self, 

603 endpoint_resolver, 

604 scoped_config=None, 

605 client_config=None, 

606 default_endpoint=None, 

607 service_signing_name=None, 

608 config_store=None, 

609 service_signature_version=None, 

610 ): 

611 self.service_signing_name = service_signing_name 

612 self.endpoint_resolver = endpoint_resolver 

613 self.scoped_config = scoped_config 

614 self.client_config = client_config 

615 self.default_endpoint = default_endpoint or self.DEFAULT_ENDPOINT 

616 self.config_store = config_store 

617 self.service_signature_version = service_signature_version 

618 

619 def resolve( 

620 self, service_name, region_name=None, endpoint_url=None, is_secure=True 

621 ): 

622 region_name = self._check_default_region(service_name, region_name) 

623 use_dualstack_endpoint = self._resolve_use_dualstack_endpoint( 

624 service_name 

625 ) 

626 use_fips_endpoint = self._resolve_endpoint_variant_config_var( 

627 'use_fips_endpoint' 

628 ) 

629 resolved = self.endpoint_resolver.construct_endpoint( 

630 service_name, 

631 region_name, 

632 use_dualstack_endpoint=use_dualstack_endpoint, 

633 use_fips_endpoint=use_fips_endpoint, 

634 ) 

635 

636 # If we can't resolve the region, we'll attempt to get a global 

637 # endpoint for non-regionalized services (iam, route53, etc) 

638 if not resolved: 

639 # TODO: fallback partition_name should be configurable in the 

640 # future for users to define as needed. 

641 resolved = self.endpoint_resolver.construct_endpoint( 

642 service_name, 

643 region_name, 

644 partition_name='aws', 

645 use_dualstack_endpoint=use_dualstack_endpoint, 

646 use_fips_endpoint=use_fips_endpoint, 

647 ) 

648 

649 if resolved: 

650 return self._create_endpoint( 

651 resolved, service_name, region_name, endpoint_url, is_secure 

652 ) 

653 else: 

654 return self._assume_endpoint( 

655 service_name, region_name, endpoint_url, is_secure 

656 ) 

657 

658 def resolver_uses_builtin_data(self): 

659 return self.endpoint_resolver.uses_builtin_data 

660 

661 def _check_default_region(self, service_name, region_name): 

662 if region_name is not None: 

663 return region_name 

664 # Use the client_config region if no explicit region was provided. 

665 if self.client_config and self.client_config.region_name is not None: 

666 return self.client_config.region_name 

667 

668 def _create_endpoint( 

669 self, resolved, service_name, region_name, endpoint_url, is_secure 

670 ): 

671 region_name, signing_region = self._pick_region_values( 

672 resolved, region_name, endpoint_url 

673 ) 

674 if endpoint_url is None: 

675 endpoint_url = self._make_url( 

676 resolved.get('hostname'), 

677 is_secure, 

678 resolved.get('protocols', []), 

679 ) 

680 signature_version = self._resolve_signature_version( 

681 service_name, resolved 

682 ) 

683 signing_name = self._resolve_signing_name(service_name, resolved) 

684 return self._create_result( 

685 service_name=service_name, 

686 region_name=region_name, 

687 signing_region=signing_region, 

688 signing_name=signing_name, 

689 endpoint_url=endpoint_url, 

690 metadata=resolved, 

691 signature_version=signature_version, 

692 ) 

693 

694 def _resolve_endpoint_variant_config_var(self, config_var): 

695 client_config = self.client_config 

696 config_val = False 

697 

698 # Client configuration arg has precedence 

699 if client_config and getattr(client_config, config_var) is not None: 

700 return getattr(client_config, config_var) 

701 elif self.config_store is not None: 

702 # Check config store 

703 config_val = self.config_store.get_config_variable(config_var) 

704 return config_val 

705 

706 def _resolve_use_dualstack_endpoint(self, service_name): 

707 s3_dualstack_mode = self._is_s3_dualstack_mode(service_name) 

708 if s3_dualstack_mode is not None: 

709 return s3_dualstack_mode 

710 return self._resolve_endpoint_variant_config_var( 

711 'use_dualstack_endpoint' 

712 ) 

713 

714 def _is_s3_dualstack_mode(self, service_name): 

715 if service_name not in self._DUALSTACK_CUSTOMIZED_SERVICES: 

716 return None 

717 # TODO: This normalization logic is duplicated from the 

718 # ClientArgsCreator class. Consolidate everything to 

719 # ClientArgsCreator. _resolve_signature_version also has similarly 

720 # duplicated logic. 

721 client_config = self.client_config 

722 if ( 

723 client_config is not None 

724 and client_config.s3 is not None 

725 and 'use_dualstack_endpoint' in client_config.s3 

726 ): 

727 # Client config trumps scoped config. 

728 return client_config.s3['use_dualstack_endpoint'] 

729 if self.scoped_config is not None: 

730 enabled = self.scoped_config.get('s3', {}).get( 

731 'use_dualstack_endpoint' 

732 ) 

733 if enabled in [True, 'True', 'true']: 

734 return True 

735 

736 def _assume_endpoint( 

737 self, service_name, region_name, endpoint_url, is_secure 

738 ): 

739 if endpoint_url is None: 

740 # Expand the default hostname URI template. 

741 hostname = self.default_endpoint.format( 

742 service=service_name, region=region_name 

743 ) 

744 endpoint_url = self._make_url( 

745 hostname, is_secure, ['http', 'https'] 

746 ) 

747 logger.debug( 

748 f'Assuming an endpoint for {service_name}, {region_name}: {endpoint_url}' 

749 ) 

750 # We still want to allow the user to provide an explicit version. 

751 signature_version = self._resolve_signature_version( 

752 service_name, {'signatureVersions': ['v4']} 

753 ) 

754 signing_name = self._resolve_signing_name(service_name, resolved={}) 

755 return self._create_result( 

756 service_name=service_name, 

757 region_name=region_name, 

758 signing_region=region_name, 

759 signing_name=signing_name, 

760 signature_version=signature_version, 

761 endpoint_url=endpoint_url, 

762 metadata={}, 

763 ) 

764 

765 def _create_result( 

766 self, 

767 service_name, 

768 region_name, 

769 signing_region, 

770 signing_name, 

771 endpoint_url, 

772 signature_version, 

773 metadata, 

774 ): 

775 return { 

776 'service_name': service_name, 

777 'region_name': region_name, 

778 'signing_region': signing_region, 

779 'signing_name': signing_name, 

780 'endpoint_url': endpoint_url, 

781 'signature_version': signature_version, 

782 'metadata': metadata, 

783 } 

784 

785 def _make_url(self, hostname, is_secure, supported_protocols): 

786 if is_secure and 'https' in supported_protocols: 

787 scheme = 'https' 

788 else: 

789 scheme = 'http' 

790 return f'{scheme}://{hostname}' 

791 

792 def _resolve_signing_name(self, service_name, resolved): 

793 # CredentialScope overrides everything else. 

794 if ( 

795 'credentialScope' in resolved 

796 and 'service' in resolved['credentialScope'] 

797 ): 

798 return resolved['credentialScope']['service'] 

799 # Use the signingName from the model if present. 

800 if self.service_signing_name: 

801 return self.service_signing_name 

802 # Just assume is the same as the service name. 

803 return service_name 

804 

805 def _pick_region_values(self, resolved, region_name, endpoint_url): 

806 signing_region = region_name 

807 if endpoint_url is None: 

808 # Do not use the region name or signing name from the resolved 

809 # endpoint if the user explicitly provides an endpoint_url. This 

810 # would happen if we resolve to an endpoint where the service has 

811 # a "defaults" section that overrides all endpoint with a single 

812 # hostname and credentialScope. This has been the case historically 

813 # for how STS has worked. The only way to resolve an STS endpoint 

814 # was to provide a region_name and an endpoint_url. In that case, 

815 # we would still resolve an endpoint, but we would not use the 

816 # resolved endpointName or signingRegion because we want to allow 

817 # custom endpoints. 

818 region_name = resolved['endpointName'] 

819 signing_region = region_name 

820 if ( 

821 'credentialScope' in resolved 

822 and 'region' in resolved['credentialScope'] 

823 ): 

824 signing_region = resolved['credentialScope']['region'] 

825 return region_name, signing_region 

826 

827 def _resolve_signature_version(self, service_name, resolved): 

828 configured_version = _get_configured_signature_version( 

829 service_name, self.client_config, self.scoped_config 

830 ) 

831 if configured_version is not None: 

832 return configured_version 

833 

834 potential_versions = resolved.get('signatureVersions', []) 

835 if ( 

836 self.service_signature_version is not None 

837 and self.service_signature_version 

838 not in _LEGACY_SIGNATURE_VERSIONS 

839 ): 

840 # Prefer the service model as most specific 

841 # source of truth for new signature versions. 

842 potential_versions = [self.service_signature_version] 

843 

844 # Pick a signature version from the endpoint metadata if present. 

845 if 'signatureVersions' in resolved: 

846 if service_name == 's3': 

847 return 's3v4' 

848 if 'v4' in potential_versions: 

849 return 'v4' 

850 # Now just iterate over the signature versions in order until we 

851 # find the first one that is known to Botocore. 

852 for known in potential_versions: 

853 if known in AUTH_TYPE_MAPS: 

854 return known 

855 raise UnknownSignatureVersionError( 

856 signature_version=potential_versions 

857 ) 

858 

859 

860class BaseClient: 

861 # This is actually reassigned with the py->op_name mapping 

862 # when the client creator creates the subclass. This value is used 

863 # because calls such as client.get_paginator('list_objects') use the 

864 # snake_case name, but we need to know the ListObjects form. 

865 # xform_name() does the ListObjects->list_objects conversion, but 

866 # we need the reverse mapping here. 

867 _PY_TO_OP_NAME = {} 

868 

869 def __init__( 

870 self, 

871 serializer, 

872 endpoint, 

873 response_parser, 

874 event_emitter, 

875 request_signer, 

876 service_model, 

877 loader, 

878 client_config, 

879 partition, 

880 exceptions_factory, 

881 endpoint_ruleset_resolver=None, 

882 user_agent_creator=None, 

883 ): 

884 self._serializer = serializer 

885 self._endpoint = endpoint 

886 self._ruleset_resolver = endpoint_ruleset_resolver 

887 self._response_parser = response_parser 

888 self._request_signer = request_signer 

889 self._cache = {} 

890 self._loader = loader 

891 self._client_config = client_config 

892 self.meta = ClientMeta( 

893 event_emitter, 

894 self._client_config, 

895 endpoint.host, 

896 service_model, 

897 self._PY_TO_OP_NAME, 

898 partition, 

899 ) 

900 self._exceptions_factory = exceptions_factory 

901 self._exceptions = None 

902 self._user_agent_creator = user_agent_creator 

903 if self._user_agent_creator is None: 

904 self._user_agent_creator = ( 

905 UserAgentString.from_environment().with_client_config( 

906 self._client_config 

907 ) 

908 ) 

909 self._register_handlers() 

910 

911 def __getattr__(self, item): 

912 service_id = self._service_model.service_id.hyphenize() 

913 event_name = f'getattr.{service_id}.{item}' 

914 

915 handler, event_response = self.meta.events.emit_until_response(