springsuite: planemo/lib/python3.7/site-packages/boto/endpoints.py comparison

comparison planemo/lib/python3.7/site-packages/boto/endpoints.py @ 0:d30785e31577 draft

"planemo upload commit 6eee67778febed82ddd413c3ca40b3183a3898f1"

author	guerler
date	Fri, 31 Jul 2020 00:18:57 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:d30785e31577
+# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+import boto.vendored.regions.regions as _regions
+class _CompatEndpointResolver(_regions.EndpointResolver):
+"""Endpoint resolver which handles boto2 compatibility concerns.
+This is NOT intended for external use whatsoever.
+"""
+_DEFAULT_SERVICE_RENAMES = {
+# The botocore resolver is based on endpoint prefix.
+# These don't always sync up to the name that boto2 uses.
+# A mapping can be provided that handles the mapping between
+# "service names" and endpoint prefixes.
+'awslambda': 'lambda',
+'cloudwatch': 'monitoring',
+'ses': 'email',
+'ec2containerservice': 'ecs',
+'configservice': 'config',
+}
+def __init__(self, endpoint_data, service_rename_map=None):
+"""
+:type endpoint_data: dict
+:param endpoint_data: Regions and endpoints data in the same format
+as is used by botocore / boto3.
+:type service_rename_map: dict
+:param service_rename_map: A mapping of boto2 service name to
+endpoint prefix.
+"""
+super(_CompatEndpointResolver, self).__init__(endpoint_data)
+if service_rename_map is None:
+service_rename_map = self._DEFAULT_SERVICE_RENAMES
+# Mapping of boto2 service name to endpoint prefix
+self._endpoint_prefix_map = service_rename_map
+# Mapping of endpoint prefix to boto2 service name
+self._service_name_map = dict(
+(v, k) for k, v in service_rename_map.items())
+def get_available_endpoints(self, service_name, partition_name='aws',
+allow_non_regional=False):
+endpoint_prefix = self._endpoint_prefix(service_name)
+return super(_CompatEndpointResolver, self).get_available_endpoints(
+endpoint_prefix, partition_name, allow_non_regional)
+def get_all_available_regions(self, service_name):
+"""Retrieve every region across partitions for a service."""
+regions = set()
+endpoint_prefix = self._endpoint_prefix(service_name)
+# Get every region for every partition in the new endpoint format
+for partition_name in self.get_available_partitions():
+if self._is_global_service(service_name, partition_name):
+# Global services are available in every region in the
+# partition in which they are considered global.
+partition = self._get_partition_data(partition_name)
+regions.update(partition['regions'].keys())
+continue
+else:
+regions.update(
+self.get_available_endpoints(
+endpoint_prefix, partition_name)
+)
+return list(regions)
+def construct_endpoint(self, service_name, region_name=None):
+endpoint_prefix = self._endpoint_prefix(service_name)
+return super(_CompatEndpointResolver, self).construct_endpoint(
+endpoint_prefix, region_name)
+def get_available_services(self):
+"""Get a list of all the available services in the endpoints file(s)"""
+services = set()
+for partition in self._endpoint_data['partitions']:
+services.update(partition['services'].keys())
+return [self._service_name(s) for s in services]
+def _is_global_service(self, service_name, partition_name='aws'):
+"""Determines whether a service uses a global endpoint.
+In theory a service can be 'global' in one partition but regional in
+another. In practice, each service is all global or all regional.
+"""
+endpoint_prefix = self._endpoint_prefix(service_name)
+partition = self._get_partition_data(partition_name)
+service = partition['services'].get(endpoint_prefix, {})
+return 'partitionEndpoint' in service
+def _get_partition_data(self, partition_name):
+"""Get partition information for a particular partition.
+This should NOT be used to get service endpoint data because it only
+loads from the new endpoint format. It should only be used for
+partition metadata and partition specific service metadata.
+:type partition_name: str
+:param partition_name: The name of the partition to search for.
+:returns: Partition info from the new endpoints format.
+:rtype: dict or None
+"""
+for partition in self._endpoint_data['partitions']:
+if partition['partition'] == partition_name:
+return partition
+raise ValueError(
+"Could not find partition data for: %s" % partition_name)
+def _endpoint_prefix(self, service_name):
+"""Given a boto2 service name, get the endpoint prefix."""
+return self._endpoint_prefix_map.get(service_name, service_name)
+def _service_name(self, endpoint_prefix):
+"""Given an endpoint prefix, get the boto2 service name."""
+return self._service_name_map.get(endpoint_prefix, endpoint_prefix)
+class BotoEndpointResolver(object):
+"""Resolves endpoint hostnames for AWS services.
+This is NOT intended for external use.
+"""
+def __init__(self, endpoint_data, service_rename_map=None):
+"""
+:type endpoint_data: dict
+:param endpoint_data: Regions and endpoints data in the same format
+as is used by botocore / boto3.
+:type service_rename_map: dict
+:param service_rename_map: A mapping of boto2 service name to
+endpoint prefix.
+"""
+self._resolver = _CompatEndpointResolver(
+endpoint_data, service_rename_map)
+def resolve_hostname(self, service_name, region_name):
+"""Resolve the hostname for a service in a particular region.
+:type service_name: str
+:param service_name: The service to look up.
+:type region_name: str
+:param region_name: The region to find the endpoint for.
+:return: The hostname for the given service in the given region.
+"""
+endpoint = self._resolver.construct_endpoint(service_name, region_name)
+if endpoint is None:
+return None
+return endpoint.get('sslCommonName', endpoint['hostname'])
+def get_all_available_regions(self, service_name):
+"""Get all the regions a service is available in.
+:type service_name: str
+:param service_name: The service to look up.
+:rtype: list of str
+:return: A list of all the regions the given service is available in.
+"""
+return self._resolver.get_all_available_regions(service_name)
+def get_available_services(self):
+"""Get all the services supported by the endpoint data.
+:rtype: list of str
+:return: A list of all the services explicitly contained within the
+endpoint data provided during instantiation.
+"""
+return self._resolver.get_available_services()
+class StaticEndpointBuilder(object):
+"""Builds a static mapping of endpoints in the legacy format."""
+def __init__(self, resolver):
+"""
+:type resolver: BotoEndpointResolver
+:param resolver: An endpoint resolver.
+"""
+self._resolver = resolver
+def build_static_endpoints(self, service_names=None):
+"""Build a set of static endpoints in the legacy boto2 format.
+:param service_names: The names of the services to build. They must
+use the names that boto2 uses, not boto3, e.g "ec2containerservice"
+and not "ecs". If no service names are provided, all available
+services will be built.
+:return: A dict consisting of::
+{"service": {"region": "full.host.name"}}
+"""
+if service_names is None:
+service_names = self._resolver.get_available_services()
+static_endpoints = {}
+for name in service_names:
+endpoints_for_service = self._build_endpoints_for_service(name)
+if endpoints_for_service:
+# It's possible that when we try to build endpoints for
+# services we get an empty hash.  In that case we don't
+# bother adding it to the final list of static endpoints.
+static_endpoints[name] = endpoints_for_service
+self._handle_special_cases(static_endpoints)
+return static_endpoints
+def _build_endpoints_for_service(self, service_name):
+# Given a service name, 'ec2', build a dict of
+# 'region' -> 'hostname'
+endpoints = {}
+regions = self._resolver.get_all_available_regions(service_name)
+for region_name in regions:
+endpoints[region_name] = self._resolver.resolve_hostname(
+service_name, region_name)
+return endpoints
+def _handle_special_cases(self, static_endpoints):
+# cloudsearchdomain endpoints use the exact same set of endpoints as
+# cloudsearch.
+if 'cloudsearch' in static_endpoints:
+cloudsearch_endpoints = static_endpoints['cloudsearch']
+static_endpoints['cloudsearchdomain'] = cloudsearch_endpoints

Mercurial > repos > guerler > springsuite

comparison planemo/lib/python3.7/site-packages/boto/endpoints.py @ 0:d30785e31577 draft