chore: update InstanceConnectionManager to Instance (#315)

Author: jackwotherspoon

google/cloud/sql/connector/__init__.py

@@ -17,7 +17,7 @@
 from typing import List
 
 from .connector import connect, Connector
-from .instance_connection_manager import IPTypes
+from .instance import IPTypes
 
 
 __ALL__ = [connect, Connector, IPTypes]

google/cloud/sql/connector/connector.py

@@ -17,8 +17,8 @@
 import concurrent
 import logging
 from types import TracebackType
-from google.cloud.sql.connector.instance_connection_manager import (
-    InstanceConnectionManager,
+from google.cloud.sql.connector.instance import (
+    Instance,
     IPTypes,
 )
 import google.cloud.sql.connector.pymysql as pymysql
@@ -70,7 +70,7 @@ def __init__(
         self._keys: concurrent.futures.Future = asyncio.run_coroutine_threadsafe(
             generate_keys(), self._loop
         )
-        self._instances: Dict[str, InstanceConnectionManager] = {}
+        self._instances: Dict[str, Instance] = {}
 
         # set default params for connections
         self._timeout = timeout
@@ -136,32 +136,32 @@ async def connect_async(
             A DB-API connection to the specified Cloud SQL instance.
         """
 
-        # Create an InstanceConnectionManager object from the connection string.
-        # The InstanceConnectionManager should verify arguments.
+        # Create an Instance object from the connection string.
+        # The Instance should verify arguments.
         #
-        # Use the InstanceConnectionManager to establish an SSL Connection.
+        # Use the Instance to establish an SSL Connection.
         #
         # Return a DBAPI connection
         enable_iam_auth = kwargs.pop("enable_iam_auth", self._enable_iam_auth)
         if instance_connection_string in self._instances:
-            icm = self._instances[instance_connection_string]
-            if enable_iam_auth != icm._enable_iam_auth:
+            instance = self._instances[instance_connection_string]
+            if enable_iam_auth != instance._enable_iam_auth:
                 raise ValueError(
                     f"connect() called with `enable_iam_auth={enable_iam_auth}`, "
-                    f"but previously used enable_iam_auth={icm._enable_iam_auth}`. "
+                    f"but previously used enable_iam_auth={instance._enable_iam_auth}`. "
                     "If you require both for your use case, please use a new "
                     "connector.Connector object."
                 )
         else:
-            icm = InstanceConnectionManager(
+            instance = Instance(
                 instance_connection_string,
                 driver,
                 self._keys,
                 self._loop,
                 self._credentials,
                 enable_iam_auth,
             )
-            self._instances[instance_connection_string] = icm
+            self._instances[instance_connection_string] = instance
 
         connect_func = {
             "pymysql": pymysql.connect,
@@ -195,7 +195,7 @@ async def connect_async(
 
         # helper function to wrap in timeout
         async def get_connection() -> Any:
-            instance_data, ip_address = await icm.connect_info(ip_type)
+            instance_data, ip_address = await instance.connect_info(ip_type)
             connect_partial = partial(
                 connector, ip_address, instance_data.context, **kwargs
             )
@@ -208,7 +208,7 @@ async def get_connection() -> Any:
             raise TimeoutError(f"Connection timed out after {timeout}s")
         except Exception as e:
             # with any other exception, we attempt a force refresh, then throw the error
-            icm.force_refresh()
+            instance.force_refresh()
             raise (e)
 
     def __enter__(self) -> Any:
@@ -231,9 +231,11 @@ def close(self) -> None:
         close_future.result(timeout=5)
 
     async def _close(self) -> None:
-        """Helper function to cancel InstanceConnectionManagers' tasks
+        """Helper function to cancel Instances' tasks
         and close aiohttp.ClientSession."""
-        await asyncio.gather(*[icm.close() for icm in self._instances.values()])
+        await asyncio.gather(
+            *[instance.close() for instance in self._instances.values()]
+        )
 
 
 def connect(instance_connection_string: str, driver: str, **kwargs: Any) -> Any:

google/cloud/sql/connector/instance_connection_manager.py renamed to google/cloud/sql/connector/instance.py

@@ -158,9 +158,9 @@ def get_preferred_ip(self, ip_type: IPTypes) -> str:
         )
 
 
-class InstanceConnectionManager:
-    """A class to manage the details of the connection, including refreshing the
-    credentials.
+class Instance:
+    """A class to manage the details of the connection to a Cloud SQL
+    instance, including refreshing the credentials.
 
     :param instance_connection_string:
         The Google Cloud SQL Instance's connection
@@ -388,9 +388,7 @@ def _schedule_refresh(self, delay: int) -> asyncio.Task:
         :returns: A Task representing the scheduled _perform_refresh.
         """
 
-        async def _refresh_task(
-            self: InstanceConnectionManager, delay: int
-        ) -> InstanceMetadata:
+        async def _refresh_task(self: Instance, delay: int) -> InstanceMetadata:
             """
             A coroutine that sleeps for the specified amount of time before
             running _perform_refresh.

google/cloud/sql/connector/pytds.py

@@ -2,7 +2,7 @@
 import socket
 import platform
 from typing import Any, TYPE_CHECKING
-from google.cloud.sql.connector.instance_connection_manager import (
+from google.cloud.sql.connector.instance import (
     PlatformNotSupportedError,
 )
 

tests/unit/test_connector.py

@@ -15,7 +15,7 @@
 """
 
 import pytest  # noqa F401 Needed to run the tests
-from google.cloud.sql.connector.instance_connection_manager import (
+from google.cloud.sql.connector.instance import (
     IPTypes,
 )
 from google.cloud.sql.connector import connector
@@ -24,7 +24,7 @@
 from typing import Any
 
 
-class MockInstanceConnectionManager:
+class MockInstance:
     _enable_iam_auth: bool
 
     def __init__(
@@ -43,7 +43,7 @@ async def connect_info(
 
 
 async def timeout_stub(*args: Any, **kwargs: Any) -> None:
-    """Timeout stub for InstanceConnectionManager.connect()"""
+    """Timeout stub for Instance.connect()"""
     # sleep 10 seconds
     await asyncio.sleep(10)
 
@@ -52,11 +52,11 @@ def test_connect_timeout() -> None:
     """Test that connection times out after custom timeout."""
     connect_string = "test-project:test-region:test-instance"
 
-    icm = MockInstanceConnectionManager()
+    instance = MockInstance()
     mock_instances = {}
-    mock_instances[connect_string] = icm
-    # stub icm to raise timeout
-    setattr(icm, "connect_info", timeout_stub)
+    mock_instances[connect_string] = instance
+    # stub instance to raise timeout
+    setattr(instance, "connect_info", timeout_stub)
     # set default connector
     default_connector = connector.Connector()
     connector._default_connector = default_connector
@@ -75,10 +75,10 @@ def test_connect_enable_iam_auth_error() -> None:
     """Test that calling connect() with different enable_iam_auth
     argument values throws error."""
     connect_string = "my-project:my-region:my-instance"
-    # create mock ICM with enable_iam_auth=False
-    icm = MockInstanceConnectionManager(enable_iam_auth=False)
+    # create mock instance with enable_iam_auth=False
+    instance = MockInstance(enable_iam_auth=False)
     mock_instances = {}
-    mock_instances[connect_string] = icm
+    mock_instances[connect_string] = instance
     # set default connector
     default_connector = connector.Connector()
     connector._default_connector = default_connector
@@ -91,7 +91,7 @@ def test_connect_enable_iam_auth_error() -> None:
             "pg8000",
             enable_iam_auth=True,
         )
-    # remove mock_icm to avoid destructor warnings
+    # remove mock_instance to avoid destructor warnings
     default_connector._instances = {}