# coding: utf-8 """ Kubernetes No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) The version of the OpenAPI document: release-1.37 Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. """ # noqa: E501 import io import json import re import ssl from typing import Any, Dict, Optional, Union import aiohttp import aiohttp_retry from kubernetes.aio.utils.retry import ( is_retry_after_response, on_retry_after_error, retry_after_backoff, ) from kubernetes.aio.client.exceptions import ApiException, ApiValueError RESTResponseType = aiohttp.ClientResponse ALLOW_RETRY_METHODS = frozenset({'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PUT', 'TRACE'}) class RESTResponse(io.IOBase): def __init__(self, resp) -> None: self.response = resp self.status = resp.status self.reason = resp.reason self.data = None async def read(self): if self.data is None: self.data = await self.response.read() return self.data @property def headers(self): """Returns a CIMultiDictProxy of response headers.""" return self.response.headers def getheaders(self): """Returns a CIMultiDictProxy of the response headers; use ``headers`` instead.""" return self.response.headers def getheader(self, name, default=None): """Returns a given response header; use ``headers.get()`` instead.""" return self.response.headers.get(name, default) class RESTClientObject: def __init__(self, configuration) -> None: # Keep a reference so factory methods (_create_pool_manager / _create_connector) # and subclasses can read extension fields like trace_configs. self.configuration = configuration # maxsize is number of requests to host that are allowed in parallel self.maxsize = configuration.connection_pool_maxsize self.ssl_context = ssl.create_default_context( cafile=configuration.ssl_ca_cert, cadata=configuration.ca_cert_data, ) if configuration.cert_file: self.ssl_context.load_cert_chain( configuration.cert_file, keyfile=configuration.key_file ) if not configuration.verify_ssl: self.ssl_context.check_hostname = False self.ssl_context.verify_mode = ssl.CERT_NONE if configuration.disable_strict_ssl_verification: self.ssl_context.verify_flags &= ~ssl.VERIFY_X509_STRICT self.proxy = configuration.proxy self.proxy_headers = configuration.proxy_headers retries = configuration.retries if retries is None: self._effective_retry_options = None elif isinstance(retries, aiohttp_retry.RetryOptionsBase): self._effective_retry_options = retries elif isinstance(retries, int): self._effective_retry_options = aiohttp_retry.ExponentialRetry( attempts=retries, factor=2.0, start_timeout=0.1, max_timeout=120.0 ) else: self._effective_retry_options = None self.pool_manager: Optional[aiohttp.ClientSession] = None self.retry_client: Optional[aiohttp_retry.RetryClient] = None async def close(self) -> None: if self.pool_manager: await self.pool_manager.close() if self.retry_client is not None: await self.retry_client.close() def _create_connector(self) -> aiohttp.TCPConnector: """Build the TCPConnector used by the ClientSession. Override in a subclass to customize DNS resolver, keepalive, etc. """ kwargs: Dict[str, Any] = { "limit": self.maxsize, "ssl": self.ssl_context, } limit_per_host = getattr(self.configuration, "tcp_connector_limit_per_host", None) if limit_per_host is not None: kwargs["limit_per_host"] = limit_per_host return aiohttp.TCPConnector(**kwargs) def _create_pool_manager(self) -> aiohttp.ClientSession: """Build the aiohttp.ClientSession used as the connection pool. Override in a subclass to fully customize the session (e.g. attach aiohttp.TraceConfig, swap json_serialize, etc.). Typed Configuration fields (trace_configs / client_session_kwargs) are read via getattr so older Configuration objects remain compatible. """ extra = getattr(self.configuration, "client_session_kwargs", None) kwargs: Dict[str, Any] = { # Preserve an explicit connector=None override. ClientSession then # creates and owns its default connector instead of using ours: # https://github.com/aio-libs/aiohttp/blob/v3.8.4/aiohttp/client.py#L238-L257 "connector": ( extra["connector"] if extra is not None and "connector" in extra else self._create_connector() ), "trust_env": True, # Kubernetes watch events can exceed aiohttp's default buffer. "read_bufsize": 2**21, } trace_configs = getattr(self.configuration, "trace_configs", None) if trace_configs is not None: kwargs["trace_configs"] = trace_configs if extra: kwargs.update(extra) if extra.get("connector") is not None: # Copied configurations can share a caller-supplied connector. # aiohttp requires connector_owner=False for shared connectors: # https://docs.aiohttp.org/en/stable/client_advanced.html#connectors kwargs["connector_owner"] = False else: kwargs["connector_owner"] = True return aiohttp.ClientSession(**kwargs) async def request( self, method, url, headers=None, body=None, post_params=None, _request_timeout=None ): """Execute request :param method: http request method :param url: http request url :param headers: http request headers :param body: request json body, for `application/json` :param post_params: request post parameters, `application/x-www-form-urlencoded` and `multipart/form-data` :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. """ method = method.upper() assert method in [ 'GET', 'HEAD', 'DELETE', 'POST', 'PUT', 'PATCH', 'OPTIONS' ] if post_params and body: raise ApiValueError( "body parameter cannot be used with post_params parameter." ) post_params = post_params or {} headers = headers or {} # url already contains the URL query string timeout = _request_timeout or 5 * 60 if 'Content-Type' not in headers: headers['Content-Type'] = 'application/json' args = { "method": method, "url": url, "timeout": timeout, "headers": headers } if self.configuration.tls_server_name: args["server_hostname"] = self.configuration.tls_server_name if self.proxy: args["proxy"] = self.proxy if self.proxy_headers: args["proxy_headers"] = self.proxy_headers # JSON Patch contains operations; object patches use strategic merge. # https://kubernetes.io/docs/reference/using-api/api-concepts/#updates-to-existing-resources if ( method == 'PATCH' and headers['Content-Type'] == 'application/json-patch+json' and not isinstance(body, list) ): headers['Content-Type'] = 'application/strategic-merge-patch+json' # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: if ( re.search('json', headers['Content-Type'], re.IGNORECASE) or headers['Content-Type'] == 'application/apply-patch+yaml' ): if body is not None: body = json.dumps(body) if body is None and post_params: body = json.dumps(dict(post_params)) args["data"] = body elif headers['Content-Type'] == 'application/x-www-form-urlencoded': args["data"] = aiohttp.FormData(post_params) elif headers['Content-Type'] == 'multipart/form-data': # must del headers['Content-Type'], or the correct # Content-Type which generated by aiohttp del headers['Content-Type'] data = aiohttp.FormData() for param in post_params: k, v = param if isinstance(v, tuple) and len(v) == 3: data.add_field( k, value=v[1], filename=v[0], content_type=v[2] ) else: # Ensures that dict objects are serialized if isinstance(v, dict): v = json.dumps(v) elif isinstance(v, int): v = str(v) data.add_field(k, v) args["data"] = data # Pass a `bytes` or `str` parameter directly in the body to support # other content types than Json when `body` argument is provided # in serialized form elif isinstance(body, str) or isinstance(body, bytes): args["data"] = body else: # Cannot generate the request from given parameters msg = """Cannot prepare a request message for provided arguments. Please check that your arguments match declared content type.""" raise ApiException(status=0, reason=msg) pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient] # https pool manager if self.pool_manager is None: self.pool_manager = self._create_pool_manager() pool_manager = self.pool_manager client_go_read_retries = ( method in ['GET', 'HEAD'] and getattr(self.configuration, 'client_go_retries', False) ) if ( self._effective_retry_options is not None and method in ALLOW_RETRY_METHODS and not client_go_read_retries ): if self.retry_client is None: self.retry_client = aiohttp_retry.RetryClient( client_session=self.pool_manager, retry_options=self._effective_retry_options ) pool_manager = self.retry_client async def read_request(check_retry_status=False): response = await self.pool_manager.request(**args) if check_retry_status: self._raise_retry_after_response(response) return response if client_go_read_retries: backoff = retry_after_backoff( getattr(self.configuration, 'retries', None), getattr(self.configuration, 'client_go_retry_backoff', None), ) r = await on_retry_after_error( backoff, self._is_read_retryable, lambda: read_request(True)) else: r = await pool_manager.request(**args) return RESTResponse(r) @classmethod def _is_read_retryable(cls, error): return is_retry_after_response(error) @staticmethod def _retry_after_error(response): error = ApiException(status=response.status, reason=response.reason) error.headers = response.headers return error @classmethod def _raise_retry_after_response(cls, response): error = cls._retry_after_error(response) if not is_retry_after_response(error): return response.release() raise error