HEX

File: //var/opt/nydus/ops/mysql/connector/__pycache__/pooling.cpython-39.pyc
a

�,�hb�@s�UdZddlmZddlZddlZddlZddlZddlmZddl	m
Z
mZmZm
Z
mZmZmZmZddlmZzddlZddlZWney�dZYn0dZzd	d
lmZWney�dZYn0d	dlmZd	dlmZmZd	d
l m!Z!m"Z"m#Z#m$Z$m%Z%d	dl&m'Z'e
�r d	dl(m)Z)e�*�Z+dZ,dZ-e�.d�Z/dZ0edu�rLeneefZ1de2d<iZ3de2d<ddd�dd�Z4ddd�dd�Z5dddd �d!d"�Z6dd#d�d$d%�Z7Gd&d�d�Z8Gd'd(�d(�Z9dS))z5Implementing pooling of connections to MySQL servers.�)�annotationsN)�
TracebackType)�
TYPE_CHECKING�Any�Dict�NoReturn�Optional�Tuple�Type�Union)�uuid4FT�)�CMySQLConnection)�MySQLConnection)�
CNX_POOL_ARGS�DEFAULT_CONFIGURATION)�Error�InterfaceError�NotSupportedError�	PoolError�ProgrammingError)�read_option_files)�MySQLConnectionAbstract� �@z[^a-zA-Z0-9._:\-*$#]z0MySQL Connector/Python C Extension not availablezUnion[type, Tuple[type, ...]]�MYSQL_CNX_CLASSzDict[str, MySQLConnectionPool]�_CONNECTION_POOLSr�PooledMySQLConnection��kwargs�returncKs�d|vr|dntfi|��}|�d�dur<tdur<tt��t�`|tvr^tfi|��t|<n4tt|t�r�t|j	}d|vr�|d|kr�t
d��Wd�n1s�0Yzt|��WSty�t
d|�d��d�Yn0dS)	z!Return a pooled MySQL connection.�	pool_name�use_pureFN�	pool_sizez)Size can not be changed for active pools.z%Failed getting connection from pool '�')�generate_pool_name�getr�ImportError�
ERROR_NO_CEXT�CONNECTION_POOL_LOCKr�MySQLConnectionPool�
isinstancer#r�get_connection�AttributeErrorr)rr!Z
check_size�r.�J/opt/nydus/tmp/pip-target-wkfpz8uv/lib64/python/mysql/connector/pooling.py�_get_pooled_connectionPs&�
&
��r0z5Union[PooledMySQLConnection, MySQLConnectionAbstract]c
Ks.|��}z|d}Wnty0td�d�Yn0|d=tgd��}d}|D]�}t|���|}|r�t|�dkrtdnd}d	�|�}td
|�d|����t|d�r�|d7}|�dd
�|d<|ddks�|dd
kr�t	d|d����t
|dt�sLt	d|d����qLd|k�r t|�k�r,nntd��i}	g}
t
|dd�dd�D]D}|d|	v�rv|g|	|d<|
�|d�n|	|d�|��qF|
D]�}|	|}tt|��D]t}
t|�d}t�d|�}|�|�}|��}|�|�|�dd�ztfi|��WSt�yYn0�q��q�t	d��dS)a�Return a MySQL connection and try to failover if needed.

    An InterfaceError is raise when no MySQL is available. ValueError is
    raised when the failover server configuration contains an illegal
    connection argument. Supported arguments are user, password, host, port,
    unix_socket and database. ValueError is also raised when the failover
    argument was not provided.

    Returns MySQLConnection instance.
    �failoverzfailover argument not providedN)	�user�password�host�port�unix_socket�databaser!r#�priorityrr
�s�z, z Unsupported connection argument z in failover: r8�dz9Priority value should be in the range of 0 to 100, got : zDPriority value should be an integer in the range of 0 to 100, got : z\You must either assign no priority to any of the routers or give a priority for every routercSs|dS)Nr8r.��xr.r.r/�<lambda>��z*_get_failover_connection.<locals>.<lambda>T)�key�reversez,Unable to connect to any of the target hosts)�copy�KeyError�
ValueError�set�keys�len�join�hasattrr&rr+�intr�sorted�append�range�random�randint�pop�update�connectr)r�configr1Zsupport_cnx_argsZpriority_count�server�diff�arg�lstZserver_directoryZserver_priority_listr8Z
failover_list�_�last�index�
new_configr.r.r/�_get_failover_connectionmst
�
�
���� �

r\)�argsrr csd�vr��d�nd}t|t�s(td��|�rts:td��d�vrJtd��d�vrZtd��d	�vrjtd
��d�vr~td�d<ztj��dd�}Wn,tj	j
y�td
�d�d��d�Yn0g}|D](}|�|jj
dd�|j|j|jd��q�|jdd�d�dd�|D��d	<d�v�r6�d�d<��d�d�v�r\tfi���}tfi|��Sd	�v�rttfi���Sz,t�fdd�tD���r�tfi���WSWnt�y�Yn0��dd�}d�v�r�d=|�s�tdu�r�tt��t�r|�st|i���St|i���S)a�Creates or gets a MySQL connection object.

    In its simpliest form, `connect()` will open a connection to a
    MySQL server and return a `MySQLConnectionAbstract` subclass
    object such as `MySQLConnection` or `CMySQLConnection`.

    When any connection pooling arguments are given, for example `pool_name`
    or `pool_size`, a pool is created or a previously one is used to return
    a `PooledMySQLConnection`.

    Args:
        *args: N/A.
        **kwargs: For a complete list of possible arguments, see [1]. If no arguments
                  are given, it uses the already configured or default values.

    Returns:
        A `MySQLConnectionAbstract` subclass instance (such as `MySQLConnection` or
        `CMySQLConnection`) or a `PooledMySQLConnection` instance.

    Examples:
        A connection with the MySQL server can be established using either the
        `mysql.connector.connect()` method or a `MySQLConnectionAbstract` subclass:
        ```
        >>> from mysql.connector import MySQLConnection, HAVE_CEXT
        >>>
        >>> cnx1 = mysql.connector.connect(user='joe', database='test')
        >>> cnx2 = MySQLConnection(user='joe', database='test')
        >>>
        >>> cnx3 = None
        >>> if HAVE_CEXT:
        >>>     from mysql.connector import CMySQLConnection
        >>>     cnx3 = CMySQLConnection(user='joe', database='test')
        ```

    References:
        [1]: https://dev.mysql.com/doc/connector-python/en/connector-python-connectargs.html
    �dns_srvFz(The value of 'dns-srv' must be a booleanztMySQL host configuration requested DNS SRV. This requires the Python dnspython module. Please refer to documentationr6z<Using Unix domain sockets with DNS SRV lookup is not allowedr5z;Specifying a port number with DNS SRV lookup is not allowedr1zASpecifying multiple hostnames with DNS SRV look up is not allowedr4ZSRVz Unable to locate any hosts for 'r$NT)Zomit_final_dot)r4r5r8�weightcSs|d|dfS)Nr8r_r.r<r.r.r/r> r?zconnect.<locals>.<lambda>)r@cSsg|]}|d|dd��qS)r4r5)r4r5r.)�.0�srvr.r.r/�
<listcomp>!szconnect.<locals>.<listcomp>Zread_default_fileZoption_filesc3s|]}|�vVqdS�Nr.)r`r@�rr.r/�	<genexpr>4r?zconnect.<locals>.<genexpr>r")rPr+�boolr�HAVE_DNSPYTHONr�dns�resolver�query�	exceptionZDNSExceptionrL�targetZto_textr5r8r_�sortrrRr\�anyrr0�	NameErrorr&rr'r(r)r]rr^Zsrv_recordsr1rar[r"r.rdr/rR�s�)
��������	�





rR�strc	KsNg}dD].}z|�t||��Wqty4Yq0q|sDtd��d�|�S)z�Generate a pool name

    This function takes keyword arguments, usually the connection
    arguments for MySQLConnection, and tries to generate a name for
    a pool.

    Raises PoolError when no name can be generated.

    Returns a string.
    )r4r5r2r7z.Failed generating pool name; specify pool_namerX)rLrprCrrH)r�partsr@r.r.r/r%Fsr%c@s�eZdZdZdddd�dd�Zdd�d	d
�Zddd
dd�dd�Zddd�dd�Zdd�dd�Ze	ddd�dd��Z
edd�dd��ZdS)ra�Class holding a MySQL Connection in a pool

    PooledMySQLConnection is used by MySQLConnectionPool to return an
    instance holding a MySQL connection. It works like a MySQLConnection
    except for methods like close() and config().

    The close()-method will add the connection back to the pool rather
    than disconnecting from the MySQL server.

    Configuring the connection have to be done through the MySQLConnectionPool
    method set_config(). Using config() on pooled connection will raise a
    PoolError.

    Attributes:
        pool_name (str): Returns the name of the connection pool to which the
                         connection belongs.
    r*r�None)�pool�cnxr cCs4t|t�std��t|t�s$td��||_||_dS)z�Constructor.

        Args:
            pool: A `MySQLConnectionPool` instance.
            cnx: A `MySQLConnectionAbstract` subclass instance.
        z$pool should be a MySQLConnectionPoolzcnx should be a MySQLConnectionN)r+r*r-r�	_cnx_pool�_cnx)�selfrsrtr.r.r/�__init__qs

zPooledMySQLConnection.__init__�r cCs|Srcr.�rwr.r.r/�	__enter__szPooledMySQLConnection.__enter__zType[BaseException]�
BaseExceptionr)�exc_type�	exc_value�	tracebackr cCs|��dSrc)�close)rwr}r~rr.r.r/�__exit__�szPooledMySQLConnection.__exit__r)�attrr cCst|j|�S)z0Calls attributes of the MySQLConnection instance)�getattrrv)rwr�r.r.r/�__getattr__�sz!PooledMySQLConnection.__getattr__c	CsFz,|j}|jjr|��W|j�|�d|_n|j�|�d|_0dS)a�Do not close, but adds connection back to pool.

        For a pooled connection, close() does not actually close it but returns it
        to the pool and makes it available for subsequent connection requests. If the
        pool configuration parameters are changed, a returned connection is closed
        and reopened with the new configuration before being returned from the pool
        again in response to a connection request.
        N)rvru�
reset_session�add_connection�rwrtr.r.r/r��s	
�zPooledMySQLConnection.closerrcKstd��dS)z�Configuration is done through the pool.

        For pooled connections, the `config()` method raises a `PoolError`
        exception. Configuration for pooled connections should be done
        using the pool object.
        zKConfiguration for pooled connections should be done through the pool itselfN)rrdr.r.r/rS�s�zPooledMySQLConnection.configrpcCs|jjS)zHReturns the name of the connection pool to which the connection belongs.)rur!rzr.r.r/r!�szPooledMySQLConnection.pool_nameN)
�__name__�
__module__�__qualname__�__doc__rxr{r�r�r��staticmethodrS�propertyr!r.r.r.r/r^sc@s�eZdZdZd*ddddd	d
�dd�Zed
d�dd��Zedd�dd��Zedd�dd��Zdd	d�dd�Z	dd	d�dd�Z
d
d	d�dd�Zdd	d�d d!�Zd+d"d	d�d#d$�Z
d%d�d&d'�Zdd�d(d)�ZdS),r*z*Class defining a pool of MySQL connections�NTrJz
Optional[str]rfrrr)r#r!�pool_reset_sessionrr cKs�d|_d|_||_|�|�|�|p0tfi|���i|_t�|j�|_	t
�|_|r�|jfi|��d}||jkr�|�
�|d7}qhdS)a�Constructor.

        Initialize a MySQL connection pool with a maximum number of
        connections set to `pool_size`. The rest of the keywords
        arguments, kwargs, are configuration arguments for MySQLConnection
        instances.

        Args:
            pool_name: The pool name. If this argument is not given, Connector/Python
                       automatically generates the name, composed from whichever of
                       the host, port, user, and database connection arguments are
                       given in kwargs, in that order.
            pool_size:  The pool size. If this argument is not given, the default is 5.
            pool_reset_session: Whether to reset session variables when the connection
                                is returned to the pool.
            **kwargs: Optional additional connection arguments, as described in [1].

        Examples:
            ```
            >>> dbconfig = {
            >>>     "database": "test",
            >>>     "user":     "joe",
            >>> }
            >>> cnxpool = mysql.connector.pooling.MySQLConnectionPool(pool_name = "mypool",
            >>>                                                       pool_size = 3,
            >>>                                                       **dbconfig)
            ```

        References:
            [1]: https://dev.mysql.com/doc/connector-python/en/connector-python-connectargs.html
        Nrr
)�
_pool_size�
_pool_name�_reset_session�_set_pool_size�_set_pool_namer%�_cnx_config�queue�Queue�
_cnx_queuer�_config_version�
set_configr�)rwr#r!r�r�cntr.r.r/rx�s &
�
zMySQLConnectionPool.__init__rprycCs|jS)z(Returns the name of the connection pool.)r�rzr.r.r/r!�szMySQLConnectionPool.pool_namecCs|jS)z2Returns number of connections managed by the pool.)r�rzr.r.r/r#�szMySQLConnectionPool.pool_sizecCs|jS)z!Returns whether to reset session.)r�rzr.r.r/r��sz!MySQLConnectionPool.reset_sessionrcKs�|sdSt�nz(t�}|jfi|��||_t�|_Wn4tyj}ztd|���|�WYd}~n
d}~00Wd�n1s�0YdS)a�Set the connection configuration for `MySQLConnectionAbstract` subclass instances.

        This method sets the configuration used for creating `MySQLConnectionAbstract`
        subclass instances such as `MySQLConnection`. See [1] for valid
        connection arguments.

        Args:
            **kwargs: Connection arguments - for a complete list of possible
                      arguments, see [1].

        Raises:
            PoolError: When a connection argument is not valid, missing
                       or not supported by `MySQLConnectionAbstract`.

        References:
            [1]: https://dev.mysql.com/doc/connector-python/en/connector-python-connectargs.html
        Nz$Connection configuration not valid: )r)rRrSr�rr�r-r)rwrZtest_cnx�errr.r.r/r��szMySQLConnectionPool.set_config)r#r cCs(|dks|tkrtdt����||_dS)aSet the size of the pool

        This method sets the size of the pool but it will not resize the pool.

        Raises an AttributeError when the pool_size is not valid. Invalid size
        is 0, negative or higher than pooling.CNX_POOL_MAXSIZE.
        rz8Pool size should be higher than 0 and lower or equal to N)�CNX_POOL_MAXSIZEr-r�)rwr#r.r.r/r�s��z"MySQLConnectionPool._set_pool_size)r!r cCs@t�|�rtd|�d���t|�tkr6td|�d���||_dS)aSet the name of the pool.

        This method checks the validity and sets the name of the pool.

        Raises an AttributeError when pool_name contains illegal characters
        ([^a-zA-Z0-9._\-*$#]) or is longer than pooling.CNX_POOL_MAXNAMESIZE.
        zPool name 'z' contains illegal charactersz
' is too longN)�CNX_POOL_NAMEREGEX�searchr-rG�CNX_POOL_MAXNAMESIZEr�)rwr!r.r.r/r�)s

z"MySQLConnectionPool._set_pool_namer)rtr c
Cs\t|t�std��z|jj|dd�Wn0tjyV}ztd�|�WYd}~n
d}~00dS)z�Put connection back in the queue

        This method is putting a connection back in the queue. It will not
        acquire a lock as the methods using _queue_connection() will have it
        set.

        Raises `PoolError` on errors.
        �;Connection instance not subclass of MySQLConnectionAbstractF��block�'Failed adding connection; queue is fullN)r+rrr��putr��Full�rwrtr�r.r.r/�_queue_connection7s	
�z%MySQLConnectionPool._queue_connectionz!Optional[MySQLConnectionAbstract]c	Cs�t��|jstd��|j��r&td��|s�tfi|j��}z(|jr`|jdr`|��dkr`td��Wnt	ytYn0|j
|_nt|t
�s�td��|�|�Wd�n1s�0YdS)a�Adds a connection to the pool.

        This method instantiates a `MySQLConnection` using the configuration
        passed when initializing the `MySQLConnectionPool` instance or using
        the `set_config()` method.
        If cnx is a `MySQLConnection` instance, it will be added to the
        queue.

        Args:
            cnx: The `MySQLConnectionAbstract` subclass object to be added to
                 the pool. If this argument is missing (aka `None`), the pool
                 creates a new connection and adds it.

        Raises:
            PoolError: When no configuration is set, when no more
                       connection can be added (maximum reached) or when the connection
                       can not be instantiated.
        z&Connection configuration not availabler��compress)r���z^Pool reset session is not supported with compression for MySQL server version 5.7.2 or earlierr�N)r)r�rr��fullrRr�Zget_server_versionrrCr��pool_config_versionr+rr�r�r.r.r/r�Js2
��
��

�z"MySQLConnectionPool.add_connectionrcCs�t��z|jjdd�}Wn0tjyH}ztd�|�WYd}~n
d}~00|��r^|j|jkr�|j	fi|j
��z|��Wnty�|�
|��Yn0|j|_t||�Wd�S1s�0YdS)a�Gets a connection from the pool.

        This method returns an PooledMySQLConnection instance which
        has a reference to the pool that created it, and the next available
        MySQL connection.

        When the MySQL connection is not connect, a reconnect is attempted.

        Returns:
            A `PooledMySQLConnection` instance.

        Raises:
            PoolError: On errors.
        Fr�z)Failed getting connection; pool exhaustedN)r)r�r&r��EmptyrZis_connectedr�r�rSr�Z	reconnectrr�rr�r.r.r/r,}s" �
�
z"MySQLConnectionPool.get_connectionc	Cs�t��d}|j}|��r�z |jdd�}|��|d7}Wqtjy^|YWd�Styp�Yqty�Yq0q|Wd�S1s�0YdS)z�Close all connections

        This method closes all connections. It returns the number
        of connections it closed.

        Used mostly for tests.

        Returns int.
        rFr�r
N)	r)r��qsizer&Z
disconnectr�r�rr)rwr�Zcnxqrtr.r.r/�_remove_connections�s
z'MySQLConnectionPool._remove_connections)r�NT)N)r�r�r�r�rxr�r!r#r�r�r�r�r�r�r,r�r.r.r.r/r*�s$�83$r*):r��
__future__rr�rN�re�	threading�typesr�typingrrrrrr	r
r�uuidrZ
dns.exceptionrhZdns.resolverr'rgZconnection_cextr�
connectionr�	constantsrr�errorsrrrrrZoptionfilesrZ	abstractsr�RLockr)r�r��compiler�r(r�__annotations__rr0r\rRr%rr*r.r.r.r/�<module>sL(


�
]|T