Fix encryption

Author: NoahStapp

pymongo/asynchronous/encryption.py

@@ -38,7 +38,7 @@
     cast,
 )
 
-from pymongo.asynchronous.pool import _async_configured_socket
+from pymongo.pool_shared import _async_configured_socket
 
 try:
     from pymongocrypt.asynchronous.auto_encrypter import AsyncAutoEncrypter  # type:ignore[import]

pymongo/asynchronous/pool.py

@@ -14,14 +14,10 @@
 
 from __future__ import annotations
 
-import asyncio
 import collections
 import contextlib
-import functools
 import logging
 import os
-import socket
-import ssl
 import sys
 import time
 import weakref
@@ -40,7 +36,7 @@
 from bson import DEFAULT_CODEC_OPTIONS
 from pymongo import _csot, helpers_shared
 from pymongo.asynchronous.client_session import _validate_session_write_concern
-from pymongo.asynchronous.helpers import _getaddrinfo, _handle_reauth
+from pymongo.asynchronous.helpers import _handle_reauth
 from pymongo.asynchronous.network import command
 from pymongo.common import (
     MAX_BSON_SIZE,
@@ -52,15 +48,13 @@
 from pymongo.errors import (  # type:ignore[attr-defined]
     AutoReconnect,
     ConfigurationError,
-    ConnectionFailure,
     DocumentTooLarge,
     ExecutionTimeout,
     InvalidOperation,
     NotPrimaryError,
     OperationFailure,
     PyMongoError,
     WaitQueueTimeoutError,
-    _CertificateError,
 )
 from pymongo.hello import Hello, HelloCompat
 from pymongo.lock import (
@@ -85,14 +79,13 @@
     _configured_protocol,
     _get_timeout_details,
     _raise_connection_failure,
-    _set_keepalive_times,
     format_timeout_details,
 )
 from pymongo.read_preferences import ReadPreference
 from pymongo.server_api import _add_to_command
 from pymongo.server_type import SERVER_TYPE
 from pymongo.socket_checker import SocketChecker
-from pymongo.ssl_support import HAS_SNI, SSLError
+from pymongo.ssl_support import SSLError
 
 if TYPE_CHECKING:
     from bson import CodecOptions
@@ -106,7 +99,6 @@
         ZstdContext,
     )
     from pymongo.message import _OpMsg, _OpReply
-    from pymongo.pyopenssl_context import _sslConn
     from pymongo.read_concern import ReadConcern
     from pymongo.read_preferences import _ServerMode
     from pymongo.typings import ClusterTime, _Address, _CollationIn
@@ -670,145 +662,6 @@ def __repr__(self) -> str:
         )
 
 
-async def _async_create_connection(address: _Address, options: PoolOptions) -> socket.socket:
-    """Given (host, port) and PoolOptions, connect and return a socket object.
-
-    Can raise socket.error.
-
-    This is a modified version of create_connection from CPython >= 2.7.
-    """
-    host, port = address
-
-    # Check if dealing with a unix domain socket
-    if host.endswith(".sock"):
-        if not hasattr(socket, "AF_UNIX"):
-            raise ConnectionFailure("UNIX-sockets are not supported on this system")
-        sock = socket.socket(socket.AF_UNIX)
-        # SOCK_CLOEXEC not supported for Unix sockets.
-        _set_non_inheritable_non_atomic(sock.fileno())
-        try:
-            sock.connect(host)
-            return sock
-        except OSError:
-            sock.close()
-            raise
-
-    # Don't try IPv6 if we don't support it. Also skip it if host
-    # is 'localhost' (::1 is fine). Avoids slow connect issues
-    # like PYTHON-356.
-    family = socket.AF_INET
-    if socket.has_ipv6 and host != "localhost":
-        family = socket.AF_UNSPEC
-
-    err = None
-    for res in await _getaddrinfo(host, port, family=family, type=socket.SOCK_STREAM):  # type: ignore[attr-defined]
-        af, socktype, proto, dummy, sa = res
-        # SOCK_CLOEXEC was new in CPython 3.2, and only available on a limited
-        # number of platforms (newer Linux and *BSD). Starting with CPython 3.4
-        # all file descriptors are created non-inheritable. See PEP 446.
-        try:
-            sock = socket.socket(af, socktype | getattr(socket, "SOCK_CLOEXEC", 0), proto)
-        except OSError:
-            # Can SOCK_CLOEXEC be defined even if the kernel doesn't support
-            # it?
-            sock = socket.socket(af, socktype, proto)
-        # Fallback when SOCK_CLOEXEC isn't available.
-        _set_non_inheritable_non_atomic(sock.fileno())
-        try:
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-            # CSOT: apply timeout to socket connect.
-            timeout = _csot.remaining()
-            if timeout is None:
-                timeout = options.connect_timeout
-            elif timeout <= 0:
-                raise socket.timeout("timed out")
-            sock.settimeout(timeout)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, True)
-            _set_keepalive_times(sock)
-            sock.connect(sa)
-            return sock
-        except OSError as e:
-            err = e
-            sock.close()
-
-    if err is not None:
-        raise err
-    else:
-        # This likely means we tried to connect to an IPv6 only
-        # host with an OS/kernel or Python interpreter that doesn't
-        # support IPv6. The test case is Jython2.5.1 which doesn't
-        # support IPv6 at all.
-        raise OSError("getaddrinfo failed")
-
-
-async def _async_configured_socket(
-    address: _Address, options: PoolOptions
-) -> Union[socket.socket, _sslConn]:
-    """Given (host, port) and PoolOptions, return a configured socket.
-
-    Can raise socket.error, ConnectionFailure, or _CertificateError.
-
-    Sets socket's SSL and timeout options.
-    """
-    sock = await _async_create_connection(address, options)
-    ssl_context = options._ssl_context
-
-    if ssl_context is None:
-        sock.settimeout(options.socket_timeout)
-        return sock
-
-    host = address[0]
-    try:
-        # We have to pass hostname / ip address to wrap_socket
-        # to use SSLContext.check_hostname.
-        if HAS_SNI:
-            if _IS_SYNC:
-                ssl_sock = ssl_context.wrap_socket(sock, server_hostname=host)
-            else:
-                if hasattr(ssl_context, "a_wrap_socket"):
-                    ssl_sock = await ssl_context.a_wrap_socket(sock, server_hostname=host)  # type: ignore[assignment, misc]
-                else:
-                    loop = asyncio.get_running_loop()
-                    ssl_sock = await loop.run_in_executor(
-                        None,
-                        functools.partial(ssl_context.wrap_socket, sock, server_hostname=host),  # type: ignore[assignment, misc]
-                    )
-        else:
-            if _IS_SYNC:
-                ssl_sock = ssl_context.wrap_socket(sock)
-            else:
-                if hasattr(ssl_context, "a_wrap_socket"):
-                    ssl_sock = await ssl_context.a_wrap_socket(sock)  # type: ignore[assignment, misc]
-                else:
-                    loop = asyncio.get_running_loop()
-                    ssl_sock = await loop.run_in_executor(None, ssl_context.wrap_socket, sock)  # type: ignore[assignment, misc]
-    except _CertificateError:
-        sock.close()
-        # Raise _CertificateError directly like we do after match_hostname
-        # below.
-        raise
-    except (OSError, SSLError) as exc:
-        sock.close()
-        # We raise AutoReconnect for transient and permanent SSL handshake
-        # failures alike. Permanent handshake failures, like protocol
-        # mismatch, will be turned into ServerSelectionTimeoutErrors later.
-        details = _get_timeout_details(options)
-        _raise_connection_failure(address, exc, "SSL handshake failed: ", timeout_details=details)
-    if (
-        ssl_context.verify_mode
-        and not ssl_context.check_hostname
-        and not options.tls_allow_invalid_hostnames
-    ):
-        try:
-            ssl.match_hostname(ssl_sock.getpeercert(), hostname=host)  # type:ignore[attr-defined]
-        except _CertificateError:
-            ssl_sock.close()
-            raise
-
-    ssl_sock.settimeout(options.socket_timeout)
-    return ssl_sock
-
-
 class _PoolClosedError(PyMongoError):
     """Internal error raised when a thread tries to get a connection from a
     closed pool.