cloud-sql-python-connector 1.17.0.dev0__py3-none-any.whl → 1.18.1__py3-none-any.whl

{cloud_sql_python_connector-1.17.0.dev0.dist-info → cloud_sql_python_connector-1.18.1.dist-info}/METADATA

@@ -1,16 +1,15 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cloud-sql-python-connector
-Version: 1.17.0.dev0
+Version: 1.18.1
 Summary: Google Cloud SQL Python Connector library
 Author-email: Google LLC <googleapis-packages@google.com>
-License: Apache 2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/GoogleCloudPlatform/cloud-sql-python-connector
 Project-URL: Repository, https://github.com/GoogleCloudPlatform/cloud-sql-python-connector.git
 Project-URL: Issues, https://github.com/GoogleCloudPlatform/cloud-sql-python-connector/issues
 Project-URL: Changelog, https://github.com/GoogleCloudPlatform/cloud-sql-python-connector/blob/main/CHANGELOG.md
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -36,6 +35,7 @@ Provides-Extra: pytds
 Requires-Dist: python-tds>=1.15.0; extra == "pytds"
 Provides-Extra: asyncpg
 Requires-Dist: asyncpg>=0.30.0; extra == "asyncpg"
+Dynamic: license-file
 
 <p align="center">
     <a href="https://cloud.google.com/blog/topics/developers-practitioners/how-connect-cloud-sql-using-python-easy-way">
@@ -165,21 +165,16 @@ import sqlalchemy
 # initialize Connector object
 connector = Connector()
 
-# function to return the database connection
-def getconn() -> pymysql.connections.Connection:
-    conn: pymysql.connections.Connection = connector.connect(
+# initialize SQLAlchemy connection pool with Connector
+pool = sqlalchemy.create_engine(
+    "mysql+pymysql://",
+    creator=lambda: connector.connect(
         "project:region:instance",
         "pymysql",
         user="my-user",
         password="my-password",
         db="my-db-name"
-    )
-    return conn
-
-# create connection pool
-pool = sqlalchemy.create_engine(
-    "mysql+pymysql://",
-    creator=getconn,
+    ),
 )
 ```
 
@@ -246,33 +241,21 @@ Connector as a context manager:
 
 ```python
 from google.cloud.sql.connector import Connector
-import pymysql
 import sqlalchemy
 
-# helper function to return SQLAlchemy connection pool
-def init_connection_pool(connector: Connector) -> sqlalchemy.engine.Engine:
-    # function used to generate database connection
-    def getconn() -> pymysql.connections.Connection:
-        conn = connector.connect(
+# initialize Cloud SQL Python Connector as context manager
+with Connector() as connector:
+    # initialize SQLAlchemy connection pool with Connector
+    pool = sqlalchemy.create_engine(
+        "mysql+pymysql://",
+        creator=lambda: connector.connect(
             "project:region:instance",
             "pymysql",
             user="my-user",
             password="my-password",
             db="my-db-name"
-        )
-        return conn
-
-    # create connection pool
-    pool = sqlalchemy.create_engine(
-        "mysql+pymysql://",
-        creator=getconn,
+        ),
     )
-    return pool
-
-# initialize Cloud SQL Python Connector as context manager
-with Connector() as connector:
-    # initialize connection pool
-    pool = init_connection_pool(connector)
     # insert statement
     insert_stmt = sqlalchemy.text(
         "INSERT INTO my_table (id, title) VALUES (:id, :title)",
@@ -440,33 +423,60 @@ from google.cloud.sql.connector import Connector, DnsResolver
 import pymysql
 import sqlalchemy
 
-# helper function to return SQLAlchemy connection pool
-def init_connection_pool(connector: Connector) -> sqlalchemy.engine.Engine:
-    # function used to generate database connection
-    def getconn() -> pymysql.connections.Connection:
-        conn = connector.connect(
+# initialize Cloud SQL Python Connector with `resolver=DnsResolver`
+with Connector(resolver=DnsResolver) as connector:
+    # initialize SQLAlchemy connection pool with Connector
+    pool = sqlalchemy.create_engine(
+        "mysql+pymysql://",
+        creator=lambda: connector.connect(
             "prod-db.mycompany.example.com",  # using DNS name
             "pymysql",
             user="my-user",
             password="my-password",
             db="my-db-name"
-        )
-        return conn
-
-    # create connection pool
-    pool = sqlalchemy.create_engine(
-        "mysql+pymysql://",
-        creator=getconn,
+        ),
     )
-    return pool
-
-# initialize Cloud SQL Python Connector with `resolver=DnsResolver`
-with Connector(resolver=DnsResolver) as connector:
-    # initialize connection pool
-    pool = init_connection_pool(connector)
     # ... use SQLAlchemy engine normally
 ```
 
+### Automatic failover using DNS domain names
+
+> [!NOTE]
+>
+> Usage of the `asyncpg` driver does not currently support automatic failover.
+
+When the connector is configured using a domain name, the connector will
+periodically check if the DNS record for an instance changes. When the connector
+detects that the domain name refers to a different instance, the connector will
+close all open connections to the old instance. Subsequent connection attempts
+will be directed to the new instance.
+
+For example: suppose application is configured to connect using the
+domain name `prod-db.mycompany.example.com`. Initially the private DNS
+zone has a TXT record with the value `my-project:region:my-instance`. The
+application establishes connections to the `my-project:region:my-instance`
+Cloud SQL instance.
+
+Then, to reconfigure the application to use a different database
+instance, change the value of the `prod-db.mycompany.example.com` DNS record
+from `my-project:region:my-instance` to `my-project:other-region:my-instance-2`
+
+The connector inside the application detects the change to this
+DNS record. Now, when the application connects to its database using the
+domain name `prod-db.mycompany.example.com`, it will connect to the
+`my-project:other-region:my-instance-2` Cloud SQL instance.
+
+The connector will automatically close all existing connections to
+`my-project:region:my-instance`. This will force the connection pools to
+establish new connections. Also, it may cause database queries in progress
+to fail.
+
+The connector will poll for changes to the DNS name every 30 seconds by default.
+You may configure the frequency of the connections using the Connector's
+`failover_period` argument (i.e. `Connector(failover_period=60`). When this is
+set to 0, the connector will disable polling and only check if the DNS record
+changed when it is creating a new connection.
+
 ### Using the Python Connector with Python Web Frameworks
 
 The Python Connector can be used alongside popular Python web frameworks such
@@ -502,9 +512,12 @@ from google.cloud.sql.connector import Connector
 # initialize Python Connector object
 connector = Connector()
 
-# Python Connector database connection function
-def getconn():
-    conn = connector.connect(
+app = Flask(__name__)
+
+# configure Flask-SQLAlchemy to use Python Connector
+app.config['SQLALCHEMY_DATABASE_URI'] = "postgresql+pg8000://"
+app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
+    "creator": lambda: conn = connector.connect(
         "project:region:instance-name", # Cloud SQL Instance Connection Name
         "pg8000",
         user="my-user",
@@ -512,15 +525,6 @@ def getconn():
         db="my-database",
         ip_type="public"  # "private" for private IP
     )
-    return conn
-
-
-app = Flask(__name__)
-
-# configure Flask-SQLAlchemy to use Python Connector
-app.config['SQLALCHEMY_DATABASE_URI'] = "postgresql+pg8000://"
-app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
-    "creator": getconn
 }
 
 # initialize the app with the extension
@@ -541,38 +545,27 @@ your web application using [SQLAlchemy ORM](https://docs.sqlalchemy.org/en/14/or
 through the following:
 
 ```python
-from sqlalchemy import create_engine
-from sqlalchemy.engine import Engine
+import sqlalchemy
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
 from google.cloud.sql.connector import Connector
 
-# helper function to return SQLAlchemy connection pool
-def init_connection_pool(connector: Connector) -> Engine:
-    # Python Connector database connection function
-    def getconn():
-        conn = connector.connect(
-            "project:region:instance-name", # Cloud SQL Instance Connection Name
-            "pg8000",
-            user="my-user",
-            password="my-password",
-            db="my-database",
-            ip_type="public"  # "private" for private IP
-        )
-        return conn
-
-    SQLALCHEMY_DATABASE_URL = "postgresql+pg8000://"
-
-    engine = create_engine(
-        SQLALCHEMY_DATABASE_URL , creator=getconn
-    )
-    return engine
 
 # initialize Cloud SQL Python Connector
 connector = Connector()
 
 # create connection pool engine
-engine = init_connection_pool(connector)
+engine = sqlalchemy.create_engine(
+    "postgresql+pg8000://",
+    creator=lambda: connector.connect(
+        "project:region:instance-name", # Cloud SQL Instance Connection Name
+        "pg8000",
+        user="my-user",
+        password="my-password",
+        db="my-database",
+        ip_type="public"  # "private" for private IP
+    ),
+)
 
 # create SQLAlchemy ORM session
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@@ -641,40 +634,29 @@ async def main():
 #### SQLAlchemy Async Engine
 
 ```python
-import asyncpg
-
 import sqlalchemy
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from google.cloud.sql.connector import Connector, create_async_connector
 
-async def init_connection_pool(connector: Connector) -> AsyncEngine:
-    # creation function to generate asyncpg connections as 'async_creator' arg
-    async def getconn() -> asyncpg.Connection:
-        conn: asyncpg.Connection = await connector.connect_async(
+
+async def main():
+    # initialize Connector object for connections to Cloud SQL
+    connector = await create_async_connector()
+
+    # The Cloud SQL Python Connector can be used along with SQLAlchemy using the
+    # 'async_creator' argument to 'create_async_engine'
+    pool = create_async_engine(
+        "postgresql+asyncpg://",
+        async_creator=lambda: connector.connect_async(
             "project:region:instance",  # Cloud SQL instance connection name
             "asyncpg",
             user="my-user",
             password="my-password",
             db="my-db-name"
             # ... additional database driver args
-        )
-        return conn
-
-    # The Cloud SQL Python Connector can be used along with SQLAlchemy using the
-    # 'async_creator' argument to 'create_async_engine'
-    pool = create_async_engine(
-        "postgresql+asyncpg://",
-        async_creator=getconn,
+        ),
     )
-    return pool
-
-async def main():
-    # initialize Connector object for connections to Cloud SQL
-    connector = await create_async_connector()
-
-    # initialize connection pool
-    pool = await init_connection_pool(connector)
 
     # example query
     async with pool.connect() as conn:
@@ -745,33 +727,24 @@ from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from google.cloud.sql.connector import Connector
 
-async def init_connection_pool(connector: Connector) -> AsyncEngine:
-    # creation function to generate asyncpg connections as 'async_creator' arg
-    async def getconn() -> asyncpg.Connection:
-        conn: asyncpg.Connection = await connector.connect_async(
-            "project:region:instance",  # Cloud SQL instance connection name
-            "asyncpg",
-            user="my-user",
-            password="my-password",
-            db="my-db-name"
-            # ... additional database driver args
-        )
-        return conn
-
-    # The Cloud SQL Python Connector can be used along with SQLAlchemy using the
-    # 'async_creator' argument to 'create_async_engine'
-    pool = create_async_engine(
-        "postgresql+asyncpg://",
-        async_creator=getconn,
-    )
-    return pool
 
 async def main():
     # initialize Connector object for connections to Cloud SQL
     loop = asyncio.get_running_loop()
     async with Connector(loop=loop) as connector:
-        # initialize connection pool
-        pool = await init_connection_pool(connector)
+        # The Cloud SQL Python Connector can be used along with SQLAlchemy using the
+        # 'async_creator' argument to 'create_async_engine'
+        pool = create_async_engine(
+            "postgresql+asyncpg://",
+            async_creator=lambda: connector.connect_async(
+                "project:region:instance",  # Cloud SQL instance connection name
+                "asyncpg",
+                user="my-user",
+                password="my-password",
+                db="my-db-name"
+                # ... additional database driver args
+            ),
+        )
 
         # example query
         async with pool.connect() as conn:

cloud_sql_python_connector-1.18.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+cloud_sql_python_connector-1.18.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+google/cloud/sql/connector/__init__.py,sha256=w6w35V-m2QlpcL-ShKd2BvNF-xXOwJ2FoidE7npPE7c,1148
+google/cloud/sql/connector/asyncpg.py,sha256=v4ohOnSYjHTOvJPhTE761xP1KKo4FUJQW_WAnNW_2g4,1918
+google/cloud/sql/connector/client.py,sha256=uVOMnRe1AxiSh6BnK4-SuSYrRID_jnm7SgMMN6s5jp4,13076
+google/cloud/sql/connector/connection_info.py,sha256=BSuW-ovtEUYTIvDzQkaE3GofCs3Xoi0TtztFaAq4Kvo,4868
+google/cloud/sql/connector/connection_name.py,sha256=bI4M3Qa2mtBHyD08oF41FF5W9FBOXWu4dGGg50Na_A4,2606
+google/cloud/sql/connector/connector.py,sha256=jukyYD75FElLvKgSHg4o91Wug21jIn87nJWNbeoTZUc,24183
+google/cloud/sql/connector/enums.py,sha256=dVBS9eEWNrHtzze0AJlmtbdUogG3EocNWOQcI_8qPd0,2937
+google/cloud/sql/connector/exceptions.py,sha256=QdQBzZ3t1RE5V744wW4sGaucWD2cEedB-dWNCkh8SAA,1974
+google/cloud/sql/connector/instance.py,sha256=jDEQf-OXFzqKO9a4bnzRQ0qUyO3_xKuiEIRWc_7wpyE,8694
+google/cloud/sql/connector/lazy.py,sha256=oB6F-O2fk8ZguY4J7Vrts91bqbVb6P5wj72Lf6UJIQA,4948
+google/cloud/sql/connector/monitored_cache.py,sha256=LFYjX8hsdN_Dt0cMwLSWgAhWWQpZ35qA0CLlpc6xhsE,5587
+google/cloud/sql/connector/pg8000.py,sha256=TnS_SNbgY19oNEawOx-qJyW-f_k42-SnR3VTBOSr5FI,1717
+google/cloud/sql/connector/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/cloud/sql/connector/pymysql.py,sha256=PrTQ1lB5EWAcN4BPX_5hb-WerncS4X76bBk4y0es0ks,1948
+google/cloud/sql/connector/pytds.py,sha256=KZxmJQQG9XfmsmUoEGX7RpMirWdoreJ2-_FuHO6Td-s,2280
+google/cloud/sql/connector/rate_limiter.py,sha256=zqZ9pVXHan4LWoGT8Bq6U3HpZcrdzKhlXVYwsX3ftA0,2928
+google/cloud/sql/connector/refresh_utils.py,sha256=Y6pT4X13b0IozmRMPuhQJRqacaGubn_mjzpFFjrXonM,5122
+google/cloud/sql/connector/resolver.py,sha256=1KYN0E-oTca8wRyW2nqCw56XRHtq-QGYpPvkk-UhjnY,3290
+google/cloud/sql/connector/utils.py,sha256=AA_oBBxRuULb7-hHHK8HQJU5fttzBpzdIZwMNZ5kNCM,3473
+google/cloud/sql/connector/version.py,sha256=EN8WaWofBDH6G6c_3vog4YS3q3OoSo7ILwETmMo8ZT0,598
+cloud_sql_python_connector-1.18.1.dist-info/METADATA,sha256=X6kdCzO2GF6gry0g9A7P8EJ1RNoTSHBJF5ft5y5PRH8,30340
+cloud_sql_python_connector-1.18.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+cloud_sql_python_connector-1.18.1.dist-info/top_level.txt,sha256=_1QvSJIhFAGfxb79D6DhB7SUw2X6T4rwnz_LLrbcD3c,7
+cloud_sql_python_connector-1.18.1.dist-info/RECORD,,

{cloud_sql_python_connector-1.17.0.dev0.dist-info → cloud_sql_python_connector-1.18.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

google/cloud/sql/connector/__init__.py

@@ -1,4 +1,4 @@
-""""
+"""
 Copyright 2019 Google LLC
 
 Licensed under the Apache License, Version 2.0 (the "License");

google/cloud/sql/connector/asyncpg.py

@@ -28,21 +28,22 @@ async def connect(
 ) -> "asyncpg.Connection":
     """Helper function to create an asyncpg DB-API connection object.
 
-    :type ip_address: str
-    :param ip_address: A string containing an IP address for the Cloud SQL
-        instance.
+    Args:
+        ip_address (str): A string containing an IP address for the Cloud SQL
+            instance.
+        ctx (ssl.SSLContext): An SSLContext object created from the Cloud SQL
+            server CA cert and ephemeral cert.
+            server CA cert and ephemeral cert.
+        kwargs: Keyword arguments for establishing asyncpg connection
+            object to Cloud SQL instance.
 
-    :type ctx: ssl.SSLContext
-    :param ctx: An SSLContext object created from the Cloud SQL server CA
-        cert and ephemeral cert.
-
-    :type kwargs: Any
-    :param kwargs: Keyword arguments for establishing asyncpg connection
-        object to Cloud SQL instance.
-
-    :rtype: asyncpg.Connection
-    :returns: An asyncpg.Connection object to a Cloud SQL instance.
+    Returns:
+        asyncpg.Connection: An asyncpg connection to the Cloud SQL
+            instance.
+    Raises:
+        ImportError: The asyncpg module cannot be imported.
     """
+
     try:
         import asyncpg
     except ImportError:

google/cloud/sql/connector/client.py

@@ -59,8 +59,7 @@ class CloudSQLClient:
         driver: Optional[str] = None,
         user_agent: Optional[str] = None,
     ) -> None:
-        """
-        Establish the client to be used for Cloud SQL Admin API requests.
+        """Establishes the client to be used for Cloud SQL Admin API requests.
 
         Args:
             sqladmin_api_endpoint (str): Base URL to use when calling
@@ -100,24 +99,22 @@ class CloudSQLClient:
         region: str,
         instance: str,
     ) -> dict[str, Any]:
-        """Requests metadata from the Cloud SQL Instance
-        and returns a dictionary containing the IP addresses and certificate
-        authority of the Cloud SQL Instance.
-
-        :type project: str
-        :param project:
-            A string representing the name of the project.
+        """Requests metadata from the Cloud SQL Instance and returns a dictionary
+        containing the IP addresses and certificate authority of the Cloud SQL
+        Instance.
 
-        :type region: str
-        :param region : A string representing the name of the region.
+        Args:
+            project (str): A string representing the name of the project.
+            region (str): A string representing the name of the region.
+            instance (str): A string representing the name of the instance.
 
-        :type instance: str
-        :param instance: A string representing the name of the instance.
+        Returns:
+            A dictionary containing a dictionary of all IP addresses
+            and their type and a string representing the certificate authority.
 
-        :rtype: dict[str: Union[dict, str]]
-        :returns: Returns a dictionary containing a dictionary of all IP
-            addresses and their type and a string representing the
-            certificate authority.
+        Raises:
+            ValueError: Provided region does not match the region of the
+                Cloud SQL instance.
         """
 
         headers = {
@@ -156,10 +153,23 @@ class CloudSQLClient:
         # resolve dnsName into IP address for PSC
         # Note that we have to check for PSC enablement also because CAS
         # instances also set the dnsName field.
-        # Remove trailing period from DNS name. Required for SSL in Python
-        dns_name = ret_dict.get("dnsName", "").rstrip(".")
-        if dns_name and ret_dict.get("pscEnabled"):
-            ip_addresses["PSC"] = dns_name
+        if ret_dict.get("pscEnabled"):
+            # Find PSC instance DNS name in the dns_names field
+            psc_dns_names = [
+                d["name"]
+                for d in ret_dict.get("dnsNames", [])
+                if d["connectionType"] == "PRIVATE_SERVICE_CONNECT"
+                and d["dnsScope"] == "INSTANCE"
+            ]
+            dns_name = psc_dns_names[0] if psc_dns_names else None
+
+            # Fall back do dns_name field if dns_names is not set
+            if dns_name is None:
+                dns_name = ret_dict.get("dnsName", None)
+
+            # Remove trailing period from DNS name. Required for SSL in Python
+            if dns_name:
+                ip_addresses["PSC"] = dns_name.rstrip(".")
 
         return {
             "ip_addresses": ip_addresses,
@@ -176,23 +186,17 @@ class CloudSQLClient:
     ) -> tuple[str, datetime.datetime]:
         """Asynchronously requests an ephemeral certificate from the Cloud SQL Instance.
 
-        :type project: str
-        :param project : A string representing the name of the project.
-
-        :type instance: str
-        :param instance: A string representing the name of the instance.
-
-        :type pub_key:
-        :param str: A string representing PEM-encoded RSA public key.
-
-        :type enable_iam_auth: bool
-        :param enable_iam_auth
-            Enables automatic IAM database authentication for Postgres or MySQL
-            instances.
+        Args:
+            project (str):  A string representing the name of the project.
+            instance (str):  string representing the name of the instance.
+            pub_key (str): A string representing PEM-encoded RSA public key.
+            enable_iam_auth (bool): Enables automatic IAM database
+                 authentication for Postgres or MySQL instances.
 
-        :rtype: str
-        :returns: An ephemeral certificate from the Cloud SQL instance that allows
-            authorized connections to the instance.
+        Returns:
+            A tuple containing an ephemeral certificate from
+            the Cloud SQL instance as well as a datetime object
+            representing the expiration time of the certificate.
         """
         headers = {
             "Authorization": f"Bearer {self._credentials.token}",

google/cloud/sql/connector/connection_info.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import abc
 from dataclasses import dataclass
 import logging
 import ssl
@@ -34,6 +35,27 @@ if TYPE_CHECKING:
 logger = logging.getLogger(name=__name__)
 
 
+class ConnectionInfoCache(abc.ABC):
+    """Abstract class for Connector connection info caches."""
+
+    @abc.abstractmethod
+    async def connect_info(self) -> ConnectionInfo:
+        pass
+
+    @abc.abstractmethod
+    async def force_refresh(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def closed(self) -> bool:
+        pass
+
+
 @dataclass
 class ConnectionInfo:
     """Contains all necessary information to connect securely to the

google/cloud/sql/connector/connection_name.py

@@ -19,6 +19,10 @@ import re
 # Additionally, we have to support legacy "domain-scoped" projects
 # (e.g. "google.com:PROJECT")
 CONN_NAME_REGEX = re.compile(("([^:]+(:[^:]+)?):([^:]+):([^:]+)"))
+# The domain name pattern in accordance with RFC 1035, RFC 1123 and RFC 2181.
+DOMAIN_NAME_REGEX = re.compile(
+    r"^(?:[_a-z0-9](?:[_a-z0-9-]{0,61}[a-z0-9])?\.)+(?:[a-z](?:[a-z0-9-]{0,61}[a-z0-9])?)?$"
+)
 
 
 @dataclass
@@ -38,6 +42,16 @@ class ConnectionName:
             return f"{self.domain_name} -> {self.project}:{self.region}:{self.instance_name}"
         return f"{self.project}:{self.region}:{self.instance_name}"
 
+    def get_connection_string(self) -> str:
+        """Get the instance connection string for the Cloud SQL instance."""
+        return f"{self.project}:{self.region}:{self.instance_name}"
+
+
+def _is_valid_domain(domain_name: str) -> bool:
+    if DOMAIN_NAME_REGEX.fullmatch(domain_name) is None:
+        return False
+    return True
+
 
 def _parse_connection_name(connection_name: str) -> ConnectionName:
     return _parse_connection_name_with_domain_name(connection_name, "")