aws-advanced-python-wrapper 1.1.0__tar.gz → 1.2.0__tar.gz

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-advanced-python-wrapper
-Version: 1.1.0
+Version: 1.2.0
 Summary: Amazon Web Services (AWS) Advanced Python Wrapper
 Home-page: https://github.com/awslabs/aws-advanced-python-wrapper
 License: Apache-2.0
@@ -257,12 +257,14 @@ This `aws-advanced-python-wrapper` is being tested against the following Communi
 
 | Database          | Versions                                                                                                                                                                                                                                                                                                                         |
 |-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| MySQL             | 8.3.0                                                                                                                                                                                                                                                                                                                            |
+| MySQL             | 8.4.0                                                                                                                                                                                                                                                                                                                            |
 | PostgreSQL        | 16.2                                                                                                                                                                                                                                                                                                                             |
 | Aurora MySQL      | - LTS version, see [here](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Updates.Versions.html#AuroraMySQL.Updates.LTS) for more details. <br><br> - Latest release, as shown on [this page](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraMySQLReleaseNotes/AuroraMySQL.Updates.30Updates.html). |
 | Aurora PostgreSQL | - LTS version, see [here](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Updates.LTS.html) for more details. <br><br> - Latest release, as shown on [this page](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html).)                        |
 
 The `aws-advanced-python-wrapper` is compatible with MySQL 5.7 and MySQL 8.0 as per MySQL Connector/Python.
+> [!WARNING]\
+> Due to recent internal changes with the `v9.0.0` MySQL Connector/Python driver in regards to connection handling, the AWS Advanced Python Wrapper is not recommended for usage with `v9.0.0`. The AWS Advanced Python Wrapper will be updated in the future for `v9.0.0` compatibility with the community driver.
 
 ## License
 

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/README.md

@@ -222,12 +222,14 @@ This `aws-advanced-python-wrapper` is being tested against the following Communi
 
 | Database          | Versions                                                                                                                                                                                                                                                                                                                         |
 |-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| MySQL             | 8.3.0                                                                                                                                                                                                                                                                                                                            |
+| MySQL             | 8.4.0                                                                                                                                                                                                                                                                                                                            |
 | PostgreSQL        | 16.2                                                                                                                                                                                                                                                                                                                             |
 | Aurora MySQL      | - LTS version, see [here](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Updates.Versions.html#AuroraMySQL.Updates.LTS) for more details. <br><br> - Latest release, as shown on [this page](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraMySQLReleaseNotes/AuroraMySQL.Updates.30Updates.html). |
 | Aurora PostgreSQL | - LTS version, see [here](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Updates.LTS.html) for more details. <br><br> - Latest release, as shown on [this page](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Updates.html).)                        |
 
 The `aws-advanced-python-wrapper` is compatible with MySQL 5.7 and MySQL 8.0 as per MySQL Connector/Python.
+> [!WARNING]\
+> Due to recent internal changes with the `v9.0.0` MySQL Connector/Python driver in regards to connection handling, the AWS Advanced Python Wrapper is not recommended for usage with `v9.0.0`. The AWS Advanced Python Wrapper will be updated in the future for `v9.0.0` compatibility with the community driver.
 
 ## License
 

aws_advanced_python_wrapper-1.2.0/aws_advanced_python_wrapper/allowed_and_blocked_hosts.py

@@ -0,0 +1,29 @@
+#   Copyright 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.
+#   You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License 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.
+
+from typing import Optional, Set
+
+
+class AllowedAndBlockedHosts:
+    def __init__(self, allowed_host_ids: Optional[Set[str]], blocked_host_ids: Optional[Set[str]]):
+        self._allowed_host_ids = None if not allowed_host_ids else allowed_host_ids
+        self._blocked_host_ids = None if not blocked_host_ids else blocked_host_ids
+
+    @property
+    def allowed_host_ids(self) -> Optional[Set[str]]:
+        return self._allowed_host_ids
+
+    @property
+    def blocked_host_ids(self) -> Optional[Set[str]]:
+        return self._blocked_host_ids

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/aurora_connection_tracker_plugin.py

@@ -50,13 +50,12 @@ class OpenedConnectionTracker:
         """
 
         aliases: FrozenSet[str] = host_info.as_aliases()
-        host: str = host_info.as_alias()
 
-        if self._rds_utils.is_rds_instance(host):
-            self._track_connection(host, conn)
+        if self._rds_utils.is_rds_instance(host_info.host):
+            self._track_connection(host_info.as_alias(), conn)
             return
 
-        instance_endpoint: Optional[str] = next((alias for alias in aliases if self._rds_utils.is_rds_instance(alias)),
+        instance_endpoint: Optional[str] = next((alias for alias in aliases if self._rds_utils.is_rds_instance(self._rds_utils.remove_port(alias))),
                                                 None)
         if not instance_endpoint:
             logger.debug("OpenedConnectionTracker.UnableToPopulateOpenedConnectionSet")
@@ -82,7 +81,7 @@ class OpenedConnectionTracker:
             return
 
         for instance in host:
-            if instance is not None and self._rds_utils.is_rds_instance(instance):
+            if instance is not None and self._rds_utils.is_rds_instance(self._rds_utils.remove_port(instance)):
                 instance_endpoint = instance
                 break
 
@@ -202,7 +201,7 @@ class AuroraConnectionTrackerPlugin(Plugin):
 
     def execute(self, target: object, method_name: str, execute_func: Callable, *args: Any, **kwargs: Any) -> Any:
         if self._current_writer is None or self._need_update_current_writer:
-            self._current_writer = self._get_writer(self._plugin_service.hosts)
+            self._current_writer = self._get_writer(self._plugin_service.all_hosts)
             self._need_update_current_writer = False
 
         try:
@@ -210,7 +209,7 @@ class AuroraConnectionTrackerPlugin(Plugin):
 
         except Exception as e:
             # Check that e is a FailoverError and that the writer has changed
-            if isinstance(e, FailoverError) and self._get_writer(self._plugin_service.hosts) != self._current_writer:
+            if isinstance(e, FailoverError) and self._get_writer(self._plugin_service.all_hosts) != self._current_writer:
                 self._tracker.invalidate_all_connections(host_info=self._current_writer)
                 self._tracker.log_opened_connections()
                 self._need_update_current_writer = True

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/aurora_initial_connection_strategy_plugin.py

@@ -198,7 +198,7 @@ class AuroraInitialConnectionStrategyPlugin(Plugin):
         sleep(delay_ms / 1000)
 
     def _get_writer(self) -> Optional[HostInfo]:
-        for host in self._plugin_service.hosts:
+        for host in self._plugin_service.all_hosts:
             if host.role == HostRole.WRITER:
                 return host
 
@@ -225,10 +225,10 @@ class AuroraInitialConnectionStrategyPlugin(Plugin):
         init_host_provider_func(props)
 
     def _has_no_readers(self) -> bool:
-        if len(self._plugin_service.hosts) == 0:
+        if len(self._plugin_service.all_hosts) == 0:
             return False
 
-        for host in self._plugin_service.hosts:
+        for host in self._plugin_service.all_hosts:
             if host.role == HostRole.READER:
                 return False
 

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/aws_secrets_manager_plugin.py

@@ -35,6 +35,7 @@ from aws_advanced_python_wrapper.utils.log import Logger
 from aws_advanced_python_wrapper.utils.messages import Messages
 from aws_advanced_python_wrapper.utils.properties import (Properties,
                                                           WrapperProperties)
+from aws_advanced_python_wrapper.utils.region_utils import RegionUtils
 from aws_advanced_python_wrapper.utils.telemetry.telemetry import \
     TelemetryTraceLevel
 
@@ -63,6 +64,7 @@ class AwsSecretsManagerPlugin(Plugin):
                 Messages.get_formatted("AwsSecretsManagerPlugin.MissingRequiredConfigParameter",
                                        WrapperProperties.SECRETS_MANAGER_SECRET_ID.name))
 
+        self._region_utils = RegionUtils()
         region: str = self._get_rds_region(secret_id, props)
 
         secrets_endpoint = WrapperProperties.SECRETS_MANAGER_ENDPOINT.get(props)
@@ -194,23 +196,22 @@ class AwsSecretsManagerPlugin(Plugin):
             WrapperProperties.PASSWORD.set(properties, self._secret.password)
 
     def _get_rds_region(self, secret_id: str, props: Properties) -> str:
-        region: Optional[str] = props.get(WrapperProperties.SECRETS_MANAGER_REGION.name)
-        if not region:
-            match = search(self._SECRETS_ARN_PATTERN, secret_id)
-            if match:
-                region = match.group("region")
-            else:
-                raise AwsWrapperError(
-                    Messages.get_formatted("AwsSecretsManagerPlugin.MissingRequiredConfigParameter",
-                                           WrapperProperties.SECRETS_MANAGER_REGION.name))
-
         session = self._session if self._session else boto3.Session()
-        if region not in session.get_available_regions("rds"):
-            exception_message = "AwsSdk.UnsupportedRegion"
-            logger.debug(exception_message, region)
-            raise AwsWrapperError(Messages.get_formatted(exception_message, region))
+        region = self._region_utils.get_region(props, WrapperProperties.SECRETS_MANAGER_REGION.name, session=session)
+
+        if region:
+            return region
 
-        return region
+        match = search(self._SECRETS_ARN_PATTERN, secret_id)
+        if match:
+            region = match.group("region")
+
+        if region:
+            return self._region_utils.verify_region(region)
+        else:
+            raise AwsWrapperError(
+                Messages.get_formatted("AwsSecretsManagerPlugin.MissingRequiredConfigParameter",
+                                       WrapperProperties.SECRETS_MANAGER_REGION.name))
 
 
 class AwsSecretsManagerPluginFactory(PluginFactory):

aws_advanced_python_wrapper-1.2.0/aws_advanced_python_wrapper/custom_endpoint_plugin.py

@@ -0,0 +1,344 @@
+#  Copyright 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.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License 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.
+
+from __future__ import annotations
+
+from threading import Event, Thread
+from time import perf_counter_ns, sleep
+from typing import (TYPE_CHECKING, Any, Callable, ClassVar, Dict, List,
+                    Optional, Set, Union, cast)
+
+from aws_advanced_python_wrapper.allowed_and_blocked_hosts import \
+    AllowedAndBlockedHosts
+from aws_advanced_python_wrapper.errors import AwsWrapperError
+from aws_advanced_python_wrapper.utils.cache_map import CacheMap
+from aws_advanced_python_wrapper.utils.messages import Messages
+from aws_advanced_python_wrapper.utils.region_utils import RegionUtils
+
+if TYPE_CHECKING:
+    from aws_advanced_python_wrapper.driver_dialect import DriverDialect
+    from aws_advanced_python_wrapper.hostinfo import HostInfo
+    from aws_advanced_python_wrapper.pep249 import Connection
+    from aws_advanced_python_wrapper.plugin_service import PluginService
+    from aws_advanced_python_wrapper.utils.properties import Properties
+
+from enum import Enum
+
+from boto3 import Session
+
+from aws_advanced_python_wrapper.plugin import Plugin, PluginFactory
+from aws_advanced_python_wrapper.utils.log import Logger
+from aws_advanced_python_wrapper.utils.properties import WrapperProperties
+from aws_advanced_python_wrapper.utils.rdsutils import RdsUtils
+from aws_advanced_python_wrapper.utils.sliding_expiration_cache import \
+    SlidingExpirationCacheWithCleanupThread
+from aws_advanced_python_wrapper.utils.telemetry.telemetry import (
+    TelemetryCounter, TelemetryFactory)
+
+logger = Logger(__name__)
+
+
+class CustomEndpointRoleType(Enum):
+    """
+    Enum representing the possible roles of instances specified by a custom endpoint. Note that, currently, it is not
+    possible to create a WRITER custom endpoint.
+    """
+    ANY = "ANY"
+    READER = "READER"
+
+    @classmethod
+    def from_string(cls, value):
+        return CustomEndpointRoleType(value)
+
+
+class CustomEndpointInfo:
+    def __init__(self,
+                 endpoint_id: str,
+                 cluster_id: str,
+                 endpoint: str,
+                 role_type: CustomEndpointRoleType,
+                 static_members: Optional[Set[str]],
+                 excluded_members: Optional[Set[str]]):
+        self.endpoint_id = endpoint_id
+        self.cluster_id = cluster_id
+        self.endpoint = endpoint
+        self.role_type = role_type
+        self.static_members = None if not static_members else static_members
+        self.excluded_members = None if not excluded_members else excluded_members
+
+    @classmethod
+    def from_db_cluster_endpoint(cls, endpoint_response_info: Dict[str, Union[str, List[str]]]):
+        return CustomEndpointInfo(
+            str(endpoint_response_info.get("DBClusterEndpointIdentifier")),
+            str(endpoint_response_info.get("DBClusterIdentifier")),
+            str(endpoint_response_info.get("Endpoint")),
+            CustomEndpointRoleType.from_string(str(endpoint_response_info.get("CustomEndpointType"))),
+            set(cast('List[str]', endpoint_response_info.get("StaticMembers"))),
+            set(cast('List[str]', endpoint_response_info.get("ExcludedMembers")))
+        )
+
+    def __eq__(self, other: object):
+        if self is object:
+            return True
+        if not isinstance(other, CustomEndpointInfo):
+            return False
+
+        return self.endpoint_id == other.endpoint_id \
+            and self.cluster_id == other.cluster_id \
+            and self.endpoint == other.endpoint \
+            and self.role_type == other.role_type \
+            and self.static_members == other.static_members \
+            and self.excluded_members == other.excluded_members
+
+    def __hash__(self):
+        return hash((self.endpoint_id, self.cluster_id, self.endpoint, self.role_type))
+
+    def __str__(self):
+        return (f"CustomEndpointInfo[endpoint={self.endpoint}, cluster_id={self.cluster_id}, "
+                f"role_type={self.role_type}, endpoint_id={self.endpoint_id}, static_members={self.static_members}, "
+                f"excluded_members={self.excluded_members}]")
+
+
+class CustomEndpointMonitor:
+    """
+    A custom endpoint monitor. This class uses a background thread to monitor a given custom endpoint for custom
+    endpoint information and future changes to the custom endpoint.
+    """
+    _CUSTOM_ENDPOINT_INFO_EXPIRATION_NS: ClassVar[int] = 5 * 60_000_000_000  # 5 minutes
+    # Keys are custom endpoint URLs, values are information objects for the associated custom endpoint.
+    _custom_endpoint_info_cache: ClassVar[CacheMap[str, CustomEndpointInfo]] = CacheMap()
+
+    def __init__(self,
+                 plugin_service: PluginService,
+                 custom_endpoint_host_info: HostInfo,
+                 endpoint_id: str,
+                 region: str,
+                 refresh_rate_ns: int,
+                 session: Optional[Session] = None):
+        self._plugin_service = plugin_service
+        self._custom_endpoint_host_info = custom_endpoint_host_info
+        self._endpoint_id = endpoint_id
+        self._region = region
+        self._refresh_rate_ns = refresh_rate_ns
+        self._session = session if session else Session()
+        self._client = self._session.client('rds', region_name=region)
+
+        self._stop_event = Event()
+        telemetry_factory = self._plugin_service.get_telemetry_factory()
+        self._info_changed_counter = telemetry_factory.create_counter("customEndpoint.infoChanged.counter")
+
+        self._thread = Thread(daemon=True, name="CustomEndpointMonitorThread", target=self._run)
+        self._thread.start()
+
+    def _run(self):
+        logger.debug("CustomEndpointMonitor.StartingMonitor", self._custom_endpoint_host_info.host)
+
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    start_ns = perf_counter_ns()
+
+                    response = self._client.describe_db_cluster_endpoints(
+                        DBClusterEndpointIdentifier=self._endpoint_id,
+                        Filters=[
+                            {
+                                "Name": "db-cluster-endpoint-type",
+                                "Values": ["custom"]
+                            }
+                        ]
+                    )
+
+                    endpoints = response["DBClusterEndpoints"]
+                    if len(endpoints) != 1:
+                        endpoint_hostnames = [endpoint["Endpoint"] for endpoint in endpoints]
+                        logger.warning(
+                            "CustomEndpointMonitor.UnexpectedNumberOfEndpoints",
+                            self._endpoint_id,
+                            self._region,
+                            len(endpoints),
+                            endpoint_hostnames)
+
+                        sleep(self._refresh_rate_ns / 1_000_000_000)
+                        continue
+
+                    endpoint_info = CustomEndpointInfo.from_db_cluster_endpoint(endpoints[0])
+                    cached_info = \
+                        CustomEndpointMonitor._custom_endpoint_info_cache.get(self._custom_endpoint_host_info.host)
+                    if cached_info is not None and cached_info == endpoint_info:
+                        elapsed_time = perf_counter_ns() - start_ns
+                        sleep_duration = max(0, self._refresh_rate_ns - elapsed_time)
+                        sleep(sleep_duration / 1_000_000_000)
+                        continue
+
+                    logger.debug(
+                        "CustomEndpointMonitor.DetectedChangeInCustomEndpointInfo",
+                        self._custom_endpoint_host_info.host, endpoint_info)
+
+                    # The custom endpoint info has changed, so we need to update the set of allowed/blocked hosts.
+                    hosts = AllowedAndBlockedHosts(endpoint_info.static_members, endpoint_info.excluded_members)
+                    self._plugin_service.allowed_and_blocked_hosts = hosts
+                    CustomEndpointMonitor._custom_endpoint_info_cache.put(
+                        self._custom_endpoint_host_info.host,
+                        endpoint_info,
+                        CustomEndpointMonitor._CUSTOM_ENDPOINT_INFO_EXPIRATION_NS)
+                    self._info_changed_counter.inc()
+
+                    elapsed_time = perf_counter_ns() - start_ns
+                    sleep_duration = max(0, self._refresh_rate_ns - elapsed_time)
+                    sleep(sleep_duration / 1_000_000_000)
+                    continue
+                except InterruptedError as e:
+                    raise e
+                except Exception as e:
+                    # If the exception is not an InterruptedError, log it and continue monitoring.
+                    logger.error("CustomEndpointMonitor.Exception", self._custom_endpoint_host_info.host, e)
+        except InterruptedError:
+            logger.info("CustomEndpointMonitor.Interrupted", self._custom_endpoint_host_info.host)
+        finally:
+            CustomEndpointMonitor._custom_endpoint_info_cache.remove(self._custom_endpoint_host_info.host)
+            self._stop_event.set()
+            self._client.close()
+            logger.debug("CustomEndpointMonitor.StoppedMonitor", self._custom_endpoint_host_info.host)
+
+    def has_custom_endpoint_info(self):
+        return CustomEndpointMonitor._custom_endpoint_info_cache.get(self._custom_endpoint_host_info.host) is not None
+
+    def close(self):
+        logger.debug("CustomEndpointMonitor.StoppingMonitor", self._custom_endpoint_host_info.host)
+        CustomEndpointMonitor._custom_endpoint_info_cache.remove(self._custom_endpoint_host_info.host)
+        self._stop_event.set()
+
+
+class CustomEndpointPlugin(Plugin):
+    """
+    A plugin that analyzes custom endpoints for custom endpoint information and custom endpoint changes, such as adding
+    or removing an instance in the custom endpoint.
+    """
+    _SUBSCRIBED_METHODS: ClassVar[Set[str]] = {"connect"}
+    _CACHE_CLEANUP_RATE_NS: ClassVar[int] = 6 * 10 ^ 10  # 1 minute
+    _monitors: ClassVar[SlidingExpirationCacheWithCleanupThread[str, CustomEndpointMonitor]] = \
+        SlidingExpirationCacheWithCleanupThread(_CACHE_CLEANUP_RATE_NS,
+                                                should_dispose_func=lambda _: True,
+                                                item_disposal_func=lambda monitor: monitor.close())
+
+    def __init__(self, plugin_service: PluginService, props: Properties):
+        self._plugin_service = plugin_service
+        self._props = props
+
+        self._should_wait_for_info: bool = WrapperProperties.WAIT_FOR_CUSTOM_ENDPOINT_INFO.get_bool(self._props)
+        self._wait_for_info_timeout_ms: int = WrapperProperties.WAIT_FOR_CUSTOM_ENDPOINT_INFO_TIMEOUT_MS.get_int(self._props)
+        self._idle_monitor_expiration_ms: int = \
+            WrapperProperties.CUSTOM_ENDPOINT_IDLE_MONITOR_EXPIRATION_MS.get_int(self._props)
+
+        self._rds_utils = RdsUtils()
+        self._region_utils = RegionUtils()
+        self._region: Optional[str] = None
+        self._custom_endpoint_host_info: Optional[HostInfo] = None
+        self._custom_endpoint_id: Optional[str] = None
+        telemetry_factory: TelemetryFactory = self._plugin_service.get_telemetry_factory()
+        self._wait_for_info_counter: TelemetryCounter = telemetry_factory.create_counter("customEndpoint.waitForInfo.counter")
+
+        CustomEndpointPlugin._SUBSCRIBED_METHODS.update(self._plugin_service.network_bound_methods)
+
+    @property
+    def subscribed_methods(self) -> Set[str]:
+        return CustomEndpointPlugin._SUBSCRIBED_METHODS
+
+    def connect(
+            self,
+            target_driver_func: Callable,
+            driver_dialect: DriverDialect,
+            host_info: HostInfo,
+            props: Properties,
+            is_initial_connection: bool,
+            connect_func: Callable) -> Connection:
+        if not self._rds_utils.is_rds_custom_cluster_dns(host_info.host):
+            return connect_func()
+
+        self._custom_endpoint_host_info = host_info
+        logger.debug("CustomEndpointPlugin.ConnectionRequestToCustomEndpoint", host_info.host)
+
+        self._custom_endpoint_id = self._rds_utils.get_cluster_id(host_info.host)
+        if not self._custom_endpoint_id:
+            raise AwsWrapperError(
+                Messages.get_formatted(
+                    "CustomEndpointPlugin.ErrorParsingEndpointIdentifier", self._custom_endpoint_host_info.host))
+
+        hostname = self._custom_endpoint_host_info.host
+        self._region = self._region_utils.get_region_from_hostname(hostname)
+        if not self._region:
+            error_message = "RdsUtils.UnsupportedHostname"
+            logger.debug(error_message, hostname)
+            raise AwsWrapperError(Messages.get_formatted(error_message, hostname))
+
+        monitor = self._create_monitor_if_absent(props)
+        if self._should_wait_for_info:
+            self._wait_for_info(monitor)
+
+        return connect_func()
+
+    def _create_monitor_if_absent(self, props: Properties) -> CustomEndpointMonitor:
+        host_info = cast('HostInfo', self._custom_endpoint_host_info)
+        endpoint_id = cast('str', self._custom_endpoint_id)
+        region = cast('str', self._region)
+        monitor = CustomEndpointPlugin._monitors.compute_if_absent(
+            host_info.host,
+            lambda key: CustomEndpointMonitor(
+                self._plugin_service,
+                host_info,
+                endpoint_id,
+                region,
+                WrapperProperties.CUSTOM_ENDPOINT_INFO_REFRESH_RATE_MS.get_int(props) * 1_000_000),
+            self._idle_monitor_expiration_ms * 1_000_000)
+
+        return cast('CustomEndpointMonitor', monitor)
+
+    def _wait_for_info(self, monitor: CustomEndpointMonitor):
+        has_info = monitor.has_custom_endpoint_info()
+        if has_info:
+            return
+
+        self._wait_for_info_counter.inc()
+        host_info = cast('HostInfo', self._custom_endpoint_host_info)
+        hostname = host_info.host
+        logger.debug("CustomEndpointPlugin.WaitingForCustomEndpointInfo", hostname, self._wait_for_info_timeout_ms)
+        wait_for_info_timeout_ns = perf_counter_ns() + self._wait_for_info_timeout_ms * 1_000_000
+
+        try:
+            while not has_info and perf_counter_ns() < wait_for_info_timeout_ns:
+                sleep(0.1)
+                has_info = monitor.has_custom_endpoint_info()
+        except InterruptedError:
+            raise AwsWrapperError(Messages.get_formatted("CustomEndpointPlugin.InterruptedThread", hostname))
+
+        if not has_info:
+            raise AwsWrapperError(
+                Messages.get_formatted(
+                    "CustomEndpointPlugin.TimedOutWaitingForCustomEndpointInfo",
+                    self._wait_for_info_timeout_ms, hostname))
+
+    def execute(self, target: type, method_name: str, execute_func: Callable, *args: Any, **kwargs: Any) -> Any:
+        if self._custom_endpoint_host_info is None:
+            return execute_func()
+
+        monitor = self._create_monitor_if_absent(self._props)
+        if self._should_wait_for_info:
+            self._wait_for_info(monitor)
+
+        return execute_func()
+
+
+class CustomEndpointPluginFactory(PluginFactory):
+    def get_instance(self, plugin_service: PluginService, props: Properties) -> Plugin:
+        return CustomEndpointPlugin(plugin_service, props)

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/driver_dialect_codes.py

@@ -13,7 +13,6 @@
 #  limitations under the License.
 
 class DriverDialectCodes:
-    SQLALCHEMY = "sqlalchemy"
     PSYCOPG = "psycopg"
     MYSQL_CONNECTOR_PYTHON = "mysql-connector-python"
     GENERIC = "generic"

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/driver_info.py

@@ -15,4 +15,4 @@
 
 class DriverInfo:
     DRIVER_NAME = "aws_advanced_python_wrapper"
-    DRIVER_VERSION = "1.0.0-rc"
+    DRIVER_VERSION = "1.2.0"

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/failover_plugin.py

@@ -25,6 +25,7 @@ if TYPE_CHECKING:
 
 from typing import Any, Callable, Dict, Optional, Set
 
+from aws_advanced_python_wrapper import LogUtils
 from aws_advanced_python_wrapper.errors import (
     AwsWrapperError, FailoverFailedError, FailoverSuccessError,
     TransactionResolutionUnknownError)
@@ -328,17 +329,23 @@ class FailoverPlugin(Plugin):
         try:
             logger.info("FailoverPlugin.StartWriterFailover")
 
-            result: WriterFailoverResult = self._writer_failover_handler.failover(self._plugin_service.hosts)
-
+            result: WriterFailoverResult = self._writer_failover_handler.failover(self._plugin_service.all_hosts)
             if result is not None and result.exception is not None:
                 raise result.exception
             elif result is None or not result.is_connected:
                 raise FailoverFailedError(Messages.get("FailoverPlugin.UnableToConnectToWriter"))
 
             writer_host = self._get_writer(result.topology)
+            allowed_hosts = self._plugin_service.hosts
+            allowed_hostnames = [host.host for host in allowed_hosts]
+            if writer_host.host not in allowed_hostnames:
+                raise FailoverFailedError(
+                    Messages.get_formatted(
+                        "FailoverPlugin.NewWriterNotAllowed",
+                        "<null>" if writer_host is None else writer_host.host,
+                        LogUtils.log_topology(allowed_hosts)))
 
             self._plugin_service.set_current_connection(result.new_connection, writer_host)
-
             logger.info("FailoverPlugin.EstablishedConnection", self._plugin_service.current_host_info)
 
             self._plugin_service.refresh_host_list()
@@ -438,11 +445,11 @@ class FailoverPlugin(Plugin):
     def _is_failover_enabled(self) -> bool:
         return self._enable_failover_setting and \
             self._rds_url_type != RdsUrlType.RDS_PROXY and \
-            self._plugin_service.hosts is not None and \
-            len(self._plugin_service.hosts) > 0
+            self._plugin_service.all_hosts is not None and \
+            len(self._plugin_service.all_hosts) > 0
 
     def _get_current_writer(self) -> Optional[HostInfo]:
-        topology = self._plugin_service.hosts
+        topology = self._plugin_service.all_hosts
         if topology is None:
             return None
 

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/fastest_response_strategy_plugin.py

@@ -50,6 +50,8 @@ MAX_VALUE = 2147483647
 class FastestResponseStrategyPlugin(Plugin):
     _FASTEST_RESPONSE_STRATEGY_NAME = "fastest_response"
     _SUBSCRIBED_METHODS: Set[str] = {"accepts_strategy",
+                                     "connect",
+                                     "force_connect",
                                      "get_host_info_by_strategy",
                                      "notify_host_list_changed"}
 
@@ -111,7 +113,7 @@ class FastestResponseStrategyPlugin(Plugin):
         fastest_response_host: Optional[HostInfo] = self._cached_fastest_response_host_by_role.get(role.name)
         if fastest_response_host is not None:
 
-            # Found a fastest host. Let's find it in the the latest topology.
+            # Found a fastest host. Let's find it in the latest topology.
             for host in self._plugin_service.hosts:
                 if host == fastest_response_host:
                     # found the fastest host in the topology

{aws_advanced_python_wrapper-1.1.0 → aws_advanced_python_wrapper-1.2.0}/aws_advanced_python_wrapper/federated_plugin.py

@@ -22,6 +22,7 @@ from urllib.parse import urlencode
 from aws_advanced_python_wrapper.credentials_provider_factory import (
     CredentialsProviderFactory, SamlCredentialsProviderFactory)
 from aws_advanced_python_wrapper.utils.iam_utils import IamAuthUtils, TokenInfo
+from aws_advanced_python_wrapper.utils.region_utils import RegionUtils
 from aws_advanced_python_wrapper.utils.saml_utils import SamlUtils
 
 if TYPE_CHECKING:
@@ -59,6 +60,7 @@ class FederatedAuthPlugin(Plugin):
         self._credentials_provider_factory = credentials_provider_factory
         self._session = session
 
+        self._region_utils = RegionUtils()
         telemetry_factory = self._plugin_service.get_telemetry_factory()
         self._fetch_token_counter = telemetry_factory.create_counter("federated.fetch_token.count")
         self._cache_size_gauge = telemetry_factory.create_gauge("federated.token_cache.size", lambda: len(FederatedAuthPlugin._token_cache))
@@ -82,7 +84,11 @@ class FederatedAuthPlugin(Plugin):
 
         host = IamAuthUtils.get_iam_host(props, host_info)
         port = IamAuthUtils.get_port(props, host_info, self._plugin_service.database_dialect.default_port)
-        region: str = IamAuthUtils.get_rds_region(self._rds_utils, host, props, self._session)
+        region = self._region_utils.get_region(props, WrapperProperties.IAM_REGION.name, host, self._session)
+        if not region:
+            error_message = "RdsUtils.UnsupportedHostname"
+            logger.debug(error_message, host)
+            raise AwsWrapperError(Messages.get_formatted(error_message, host))
 
         user = WrapperProperties.DB_USER.get(props)
         cache_key: str = IamAuthUtils.get_cache_key(