def __init_connection(self, url=None): """Function for initiating connection with remote server :param url: The URL of the remote system :type url: str """ self.__destroy_connection() url = url if url else self.__url if url.scheme.upper() == "HTTPS": if sys.version_info < (2, 7, 9): self._conn = http_client.HTTPSConnection(url.netloc) else: self._conn = http_client.HTTPSConnection(url.netloc, \ context=ssl._create_unverified_context()) elif url.scheme.upper() == "HTTP": self._conn = http_client.HTTPConnection(url.netloc) else: pass
def create_connection(parsed_url): """Helper function to create connection with httplib :param parsed_url: parsed url of the remote location """ if parsed_url.scheme == 'https': conn = httplib.HTTPSConnection(parsed_url.netloc) else: conn = httplib.HTTPConnection(parsed_url.netloc) return conn
def _call(self, action, resource, data, headers, binary=False): if resource.startswith('http'): uri = resource else: uri = self.base_uri + resource if binary: body = data else: body = jsonutils.dumps(data) debug_data = 'binary' if binary else body debug_data = debug_data if debug_data else 'EMPTY' if not headers: headers = {'Authorization': 'Basic %s' % self.auth} else: headers['Authorization'] = 'Basic %s' % self.auth conn = None if self.ssl: conn = http_client.HTTPSConnection(self.server, self.port, timeout=self.timeout) if conn is None: LOG.error( _LE('vdirectRESTClient: Could not establish HTTPS ' 'connection')) return 0, None, None, None else: conn = http_client.HTTPConnection(self.server, self.port, timeout=self.timeout) if conn is None: LOG.error( _LE('vdirectRESTClient: Could not establish HTTP ' 'connection')) return 0, None, None, None try: conn.request(action, uri, body, headers) response = conn.getresponse() respstr = response.read() respdata = respstr try: respdata = jsonutils.loads(respstr) except ValueError: # response was not JSON, ignore the exception pass ret = (response.status, response.reason, respstr, respdata) except Exception as e: log_dict = {'action': action, 'e': e} LOG.error(_LE('vdirectRESTClient: %(action)s failure, %(e)r'), log_dict) ret = -1, None, None, None conn.close() return ret
def __init__(self, uri_or_host, speedThrift=False, port=None, path=None): """THttpClient supports two different types constructor parameters. THttpClient(host, port, path) - deprecated THttpClient(uri) Only the second supports https. """ if port is not None: warnings.warn( "Please use the THttpClient('http://host:port/path') syntax", DeprecationWarning, stacklevel=2) self.host = uri_or_host self.port = port assert path self.path = path self.scheme = 'http' else: parsed = urllib.parse.urlparse(uri_or_host) self.scheme = parsed.scheme assert self.scheme in ('http', 'https') if self.scheme == 'http': self.port = parsed.port or http_client.HTTP_PORT elif self.scheme == 'https': self.port = parsed.port or http_client.HTTPS_PORT self.host = parsed.hostname self.path = parsed.path if parsed.query: self.path += '?%s' % parsed.query try: proxy = urllib.request.getproxies()[self.scheme] except KeyError: proxy = None else: if urllib.request.proxy_bypass(self.host): proxy = None if proxy: parsed = urllib.parse.urlparse(proxy) self.realhost = self.host self.realport = self.port self.host = parsed.hostname self.port = parsed.port self.proxy_auth = self.basic_proxy_auth_header(parsed) else: self.realhost = self.realport = self.proxy_auth = None self.__wbuf = BytesIO() self.__http = http_client.HTTPSConnection(self.host, self.port) #None self.__http_response = None self.__timeout = None self.__custom_headers = None self.__timeStart = time.time() self.__speedThrift = speedThrift
def _performAction(self, actionName, params=None): if not params: params = {} params['Action'] = actionName #https://email.us-east-1.amazonaws.com/ conn = http_client.HTTPSConnection('email.us-east-1.amazonaws.com') params = urlencode(params) conn.request('POST', '/', params, self._getHeaders()) response = conn.getresponse() responseResult = response.read() conn.close() return self._responseParser.parse(actionName, response.status, response.reason, responseResult)
def prepare_upload_key(self, key, public_id, private_id, serial=None, user_agent='python-yubikey-manager/' + __version__): modhex_public_id = modhex_encode(public_id) data = { 'aes_key': b2a_hex(key).decode('utf-8'), 'serial': serial or 0, 'public_id': modhex_public_id, 'private_id': b2a_hex(private_id).decode('utf-8'), } httpconn = http_client.HTTPSConnection(UPLOAD_HOST, timeout=1) # nosec try: httpconn.request('POST', UPLOAD_PATH, body=json.dumps(data, indent=False, sort_keys=True).encode('utf-8'), headers={ 'Content-Type': 'application/json', 'User-Agent': user_agent, }) except Exception as e: logger.error('Failed to connect to %s', UPLOAD_HOST, exc_info=e) raise PrepareUploadFailed(None, None, [PrepareUploadError.CONNECTION_FAILED]) resp = httpconn.getresponse() if resp.status == 200: url = json.loads(resp.read().decode('utf-8'))['finish_url'] return url else: resp_body = resp.read() logger.debug('Upload failed with status %d: %s', resp.status, resp_body) if resp.status == 404: raise PrepareUploadFailed(resp.status, resp_body, [PrepareUploadError.NOT_FOUND]) elif resp.status == 503: raise PrepareUploadFailed( resp.status, resp_body, [PrepareUploadError.SERVICE_UNAVAILABLE]) else: try: errors = json.loads( resp_body.decode('utf-8')).get('errors') except Exception: errors = [] raise PrepareUploadFailed(resp.status, resp_body, errors)
def test_http_mock_failure(self): mock_body = '{"error": "no results matching query", "status": 413}' self.mock_response.read.return_value = mock_body self.mock_response.status = 413 conn = http_client.HTTPSConnection('whatever', None) conn.request('GET', '/blah', '{}', {}) rsp = conn.getresponse() self.assertEqual(mock_body, rsp.read()) self.assertEqual(413, rsp.status)
def _fetch_response_xml(self, request_xml): # Need to fill in HTTP request here conn = http_client.HTTPSConnection(self._host, 443, timeout=30) headers = {"Content-type": "application/xml", "Accept": ""} conn.request("POST", self._path, request_xml.encode('utf8'), headers) response = conn.getresponse() response_xml = response.read() if response.status != http_client.OK: raise GatewayError("Unable to communicate with payment gateway (code: %s, response: %s)" % (response.status, response_xml)) conn.close() return response_xml
def __GetElementTree(protocol, server, port, path, sslContext, httpProxyHost=None, httpProxyPort=None): """ Private method that returns a root from ElementTree for a remote XML document. @param protocol: What protocol to use for the connection (e.g. https or http). @type protocol: string @param server: Which server to connect to. @type server: string @param port: Port @type port: int @param path: Path @type path: string @param sslContext: SSL Context describing the various SSL options. It is only supported in Python 2.7.9 or higher. @type sslContext: SSL.Context """ if httpProxyHost: kwargs = {"context": sslContext} if sslContext else {} conn = http_client.HTTPSConnection(httpProxyHost, port=httpProxyPort, **kwargs) conn.set_tunnel(server, port) elif protocol == "https": kwargs = {"context": sslContext} if sslContext else {} # IPv6 requires None as the port if port: server = server + ":" + str(port) conn = http_client.HTTPSConnection(server, None, **kwargs) elif protocol == "http": conn = http_client.HTTPConnection(server, port=port) else: raise Exception("Protocol " + protocol + " not supported.") conn.request("GET", path) response = conn.getresponse() if response.status == 200: try: tree = ElementTree.fromstring(response.read()) return tree except ExpatError: pass return None
def open(self): if self.scheme == 'http': self.__http = http_client.HTTPConnection(self.host, self.port, timeout=self.__timeout) elif self.scheme == 'https': self.__http = http_client.HTTPSConnection(self.host, self.port, key_file=self.keyfile, cert_file=self.certfile, timeout=self.__timeout, context=self.context) if self.using_proxy(): self.__http.set_tunnel(self.realhost, self.realport, {"Proxy-Authorization": self.proxy_auth})
def get_connection_secure(self, verbose): """ Notes ----------------- Add certificate to connection """ # Prepare the certificate context = ssl.create_default_context() if self.__certificate: context.load_cert_chain(self.__certificate) return httplib.HTTPSConnection(self._ConnectionHandler__connHost, self._ConnectionHandler__connPortSsl, context=context)
def rpc_pypi(method, *args): """Call an XML-RPC method on the Pypi server.""" conn = http_client.HTTPSConnection(PYPI_HOSTNAME) headers = {'Content-Type': 'text/xml'} payload = xmlrpc_client.dumps(args, method) conn.request("POST", "/pypi", payload, headers) response = conn.getresponse() if response.status == 200: result = xmlrpc_client.loads(response.read())[0][0] return result else: raise RuntimeError("Unable to download the list of top " "packages from Pypi.")
def __init__(self, uri_or_host, port=None, path=None, customThrift=True): """THttpClient supports two different types constructor parameters. THttpClient(host, port, path) - deprecated THttpClient(uri) Only the second supports https. """ if port is not None: warnings.warn( "Please use the THttpClient('http://host:port/path') syntax", DeprecationWarning, stacklevel=2 ) self.host = uri_or_host self.port = port assert path self.path = path self.scheme = 'http' else: parsed = urllib.parse.urlparse(uri_or_host) self.scheme = parsed.scheme assert self.scheme in ('http', 'https') if self.scheme == 'http': self.port = parsed.port or http_client.HTTP_PORT elif self.scheme == 'https': self.port = parsed.port or http_client.HTTPS_PORT self.host = parsed.hostname self.path = parsed.path if parsed.query: self.path += '?%s' % parsed.query proxy = None self.realhost = self.realport = self.proxy_auth = None self.__wbuf = BytesIO() if customThrift: if self.scheme == 'http': self.__http = http_client.HTTPConnection(self.host, self.port) elif self.scheme == 'https': self.__http = http_client.HTTPSConnection(self.host, self.port) else: self.__http = None self.__http_response = None self.__timeout = None self.__custom_headers = None self.__time = time.time() self.__custom_thrift = customThrift self.__loop = 0
def _connect(self): ''' Initialize an HTTP/HTTPS connection with chunked Transfer-Encoding to server:port with optional headers. ''' server = self._server port = self._port headers = self._headers ssl_enabled = self._ssl_enabled proxy_server, proxy_port = self._get_proxy_config() if (proxy_server and proxy_port): if ssl_enabled: self._conn = http_client.HTTPSConnection( proxy_server, proxy_port) else: self._conn = http_client.HTTPConnection( proxy_server, proxy_port) self._conn.set_tunnel(server, port) else: if ssl_enabled: self._conn = http_client.HTTPSConnection(server, port) else: self._conn = http_client.HTTPConnection(server, port) self._conn.putrequest('POST', self._url) self._conn.putheader('Transfer-Encoding', 'chunked') for header in headers: self._conn.putheader(header, headers[header]) self._conn.endheaders() # Set blocking to False prevents recv # from blocking while waiting for a response. self._conn.sock.setblocking(False) self._bytes = six.b('') self._reset_retries() time.sleep(0.5)
def get_connection(self, ishttps=False, cookie=None, verbose=False): """ Notes ----------------- If using certificates get secure not if using cookies """ if self.__certificate is not None: if verbose: print("------>Cert") return self.get_connection_secure(verbose) else: if verbose: print("------>Cookie") return httplib.HTTPSConnection(self._ConnectionHandler__connHost, self._ConnectionHandler__connPort)
def http_connection(session): conn = None xs_url = urllib.parse.urlparse(session.url) LOG.debug("Creating http(s) connection to %s" % session.url) if xs_url.scheme == 'http': conn = http_client.HTTPConnection(xs_url.netloc) elif xs_url.scheme == 'https': conn = http_client.HTTPSConnection(xs_url.netloc) conn.connect() try: yield conn finally: conn.close()
def request(self, endpoint, method=None, body=None, headers=None): # Strip 'https://' https_con = http_client.HTTPSConnection( endpoint[8:].split('/')[0]) https_con.request(method, endpoint, body=body, headers=headers) response = https_con.getresponse() # Return status like an httplib2 response. return ({'status': response.status}, )
def send_message(message): message = message.encode('utf-8') headers = { b'Content-Type': b'text/xml', b'SOAPAction': b'urn:ec.europa.eu:taxud:tic:services:VatRateWebService' } tries = 0 response = None while response is None or (tries < 5 and response.status >= 500 and response.status <= 599): if tries > 0: if response is not None: # Cope with badly behaved web service returning 500 for non- # server errors body = response.read() if body.startswith(b'<soap:'): root = etree.fromstring(body) fault = root.find('.//' + SOAP_NS + 'Fault') faultcode = fault.find('./{*}faultcode').text faultstring = fault.find('./{*}faultstring').text faultactor = fault.find('./{*}faultactor') if faultactor is not None: faultactor = faultactor.text detail = fault.find('./{*}detail') if detail is not None: detail = detail.text m = _error_re.match(faultstring) if m: raise VRWSErrorException(int(m.group(1)), m.group(2)) raise VRWSSOAPException(faultcode, faultstring, faultactor, detail) time.sleep(tries) tries += 1 conn = http_client.HTTPSConnection(VRWS_HOST) conn.request(str('POST'), VRWS_PATH, message, headers) response = conn.getresponse() if response.status != 200: raise VRWSHTTPException(response.status, response.reason, response.getheaders(), response.read()) return response
def _vhd_stream_to_vdi(self, vhd_file_parser, vdi_ref, file_size): headers = { 'Content-Type': 'application/octet-stream', 'Content-Length': '%s' % file_size } if self.host_url.scheme == 'http': conn = httplib.HTTPConnection(self.host_url.netloc) elif self.host_url.scheme == 'https': conn = httplib.HTTPSConnection(self.host_url.netloc) vdi_import_path = utils.get_vdi_import_path(self.session, self.task_ref, vdi_ref) try: conn.connect() except Exception: LOG.error('Failed connecting to host: %s', self.host_url.netloc) raise exception.HostConnectionFailure( host_netloc=self.host_url.netloc) try: conn.request('PUT', vdi_import_path, headers=headers) # Send the data already processed by vhd file parser firstly; # then send the remaining data from the stream. conn.send(vhd_file_parser.cached_buff) remain_size = file_size - len(vhd_file_parser.cached_buff) file_obj = vhd_file_parser.src_file while remain_size >= CHUNK_SIZE: chunk = file_obj.read(CHUNK_SIZE) remain_size -= CHUNK_SIZE conn.send(chunk) if remain_size != 0: chunk = file_obj.read(remain_size) conn.send(chunk) except Exception: LOG.error('Failed importing VDI from VHD stream - vdi_ref:%s', vdi_ref) raise exception.VdiImportFailure(vdi_ref=vdi_ref) finally: resp = conn.getresponse() LOG.debug( "Connection response status/reason is " "%(status)s:%(reason)s", { 'status': resp.status, 'reason': resp.reason }) conn.close()
def request(self, method, path, callback, body="", headers={}, query_params=""): """ This method creates a connection to a remote host, sends a request to that host, and then waits for and reads the response from that request. :param str method: The request method (e.g. "POST") :param str path: The path for the URL :param Function callback: The function that gets called when this operation is complete or has failed. The callback function must accept an error and a response dictionary, where the response dictionary contains a status code, a reason, and a response string. :param str body: The body of the HTTP request to be sent following the headers. :param dict headers: A dictionary that provides extra HTTP headers to be sent with the request. :param str query_params: The optional query parameters to be appended at the end of the URL. """ # Sends a complete request to the server logger.info("sending https request.") try: logger.debug("creating an https connection") connection = http_client.HTTPSConnection(self._hostname, context=self._ssl_context) logger.debug("connecting to host tcp socket") connection.connect() logger.debug("connection succeeded") url = "https://{hostname}/{path}{query_params}".format( hostname=self._hostname, path=path, query_params="?" + query_params if query_params else "", ) logger.debug("Sending Request to HTTP URL: {}".format(url)) logger.debug("HTTP Headers: {}".format(headers)) logger.debug("HTTP Body: {}".format(body)) connection.request(method, url, body=body, headers=headers) response = connection.getresponse() status_code = response.status reason = response.reason response_string = response.read() logger.debug("response received") logger.debug("closing connection to https host") connection.close() logger.debug("connection closed") logger.info("https request sent, and response received.") response_obj = {"status_code": status_code, "reason": reason, "resp": response_string} callback(response=response_obj) except Exception as e: logger.error("Error in HTTP Transport: {}".format(e)) callback( error=exceptions.ProtocolClientError( message="Unexpected HTTPS failure during connect", cause=e ) )
def list(self): if isinstance(self.hotfixes, dict): return self.hotfixes self.hotfixes = {} conn = http_client.HTTPSConnection(self.url.netloc) try: conn.request('GET', self.url.path) response = conn.getresponse() except Exception as error: logging.warning("Could not get hotfix list: %s", error) return {} hotfixes = yaml.load(response) for name in hotfixes: if not HotFixManager.isHotfixValid(hotfixes[name]): continue self.hotfixes[name] = self.processHotfix(name, hotfixes[name]) return self.hotfixes
def make_connection(self, host): if self._connection and host == self._connection[0]: return self._connection[1] chost, self._extra_headers, x509 = self.get_host_info(host) if self.secure: try: self._connection = host, httplib.HTTPSConnection( chost, None, **(x509 or {})) except AttributeError: raise NotImplementedError( 'In use version of httplib doesn\'t support HTTPS') else: self._connection = host, httplib.HTTPConnection(chost) return self._connection[1]
def _request(self, method, url): con = http_client.HTTPSConnection(self.host, timeout=self.timeout) with closing(con): log.debug("%s host=%s url=%s", method, self.host, url) con.request(method, url) res = con.getresponse() body = res.read() if res.status != http_client.OK: raise Error( "Request failed host={} url={} reason={} body={!r}".format( host, url, res.reason, body)) log.debug("OK headers=%s", res.getheaders()) if body.startswith(_MAGIC_PREFIX): body = body[len(_MAGIC_PREFIX):] return json.loads(body)
def do_http(method, url, body=b""): if isinstance(body, bytes): body = BytesIO(body) elif isinstance(body, six.text_type): raise TypeError("do_http body must be a bytestring, not unicode") else: # We must give a Content-Length header to twisted.web, otherwise it # seems to get a zero-length file. I suspect that "chunked-encoding" # may fix this. assert body.tell assert body.seek assert body.read scheme, host, port, path = parse_url(url) if scheme == "http": c = http_client.HTTPConnection(host, port) elif scheme == "https": c = http_client.HTTPSConnection(host, port) else: raise ValueError("unknown scheme '%s', need http or https" % scheme) c.putrequest(method, path) c.putheader("Hostname", host) c.putheader("User-Agent", allmydata.__full_version__ + " (tahoe-client)") c.putheader("Accept", "text/plain, application/octet-stream") c.putheader("Connection", "close") old = body.tell() body.seek(0, os.SEEK_END) length = body.tell() body.seek(old) c.putheader("Content-Length", str(length)) try: c.endheaders() except socket_error as err: return BadResponse(url, err) while True: data = body.read(8192) if not data: break c.send(data) return c.getresponse()
def _connect(self): # Host and port for the HTTP(S) connection to the API server. if self.ca_certs == 'HTTP': api_port = 80 else: api_port = 443 if self.port is not None: api_port = self.port # Host and port for outer HTTP(S) connection if proxied. if self.proxy_type is None: host = self.host port = api_port elif self.proxy_type == 'CONNECT': host = self.proxy_host port = self.proxy_port else: raise NotImplementedError('proxy_type=%s' % (self.proxy_type, )) # Create outer HTTP(S) connection. if self.ca_certs == 'HTTP': conn = http_client.HTTPConnection(host, port) elif self.ca_certs == 'DISABLE': conn = http_client.HTTPSConnection(host, port) else: conn = CertValidatingHTTPSConnection(host, port, ca_certs=self.ca_certs) # Override default socket timeout if requested. conn.timeout = self.timeout # Configure CONNECT proxy tunnel, if any. if self.proxy_type == 'CONNECT': if hasattr(conn, 'set_tunnel'): # 2.7+ conn.set_tunnel(self.host, api_port, self.proxy_headers) elif hasattr(conn, '_set_tunnel'): # 2.6.3+ # pylint: disable=E1103 conn._set_tunnel(self.host, api_port, self.proxy_headers) # pylint: enable=E1103 return conn
def open(self): if self.request == 'hyper': if self.http2: self.__http = hyper.HTTP20Connection( self.host, self.port, proxy_host=self.realhost, proxy_port=self.realport, proxy_headers=self.proxy_headers) else: self.__http = hyper.HTTPConnection( self.host, self.port, proxy_host=self.realhost, proxy_port=self.realport, proxy_headers=self.proxy_headers) elif self.request == 'httpx': if self.http2: self.__http = httpx.AsyncClient(base_url='%s://%s' % (self.scheme, self.host), http2=self.http2) else: self.__http = httpx.Client(base_url='%s://%s' % (self.scheme, self.host)) elif self.request == 'requests': self.__http = requests.Session() if self.using_proxy(): self.__http.proxies = urllib.request.getproxies() elif self.request == 'requests-futures': self.__http = FuturesSession() if self.using_proxy(): self.__http.proxies = urllib.request.getproxies() elif self.request == 'httplib2': self.__http = httplib2.Http() else: if self.scheme == 'http': self.__http = http_client.HTTPConnection(self.host, self.port) elif self.scheme == 'https': self.__http = http_client.HTTPSConnection(self.host, self.port) if self.using_proxy(): self.__http.set_tunnel(self.realhost, self.realport, self.proxy_headers)
def request(self, method, path, body=None, headers=None): if not headers: headers = {} headers.update(self.default_headers) if not self.port: self.port = 443 if self.secure else 80 if self.secure: ctx = ssl.SSLContext(ssl.PROTOCOL_TLS) self.http_conn = http_client.HTTPSConnection(self.host, self.port, timeout=self.timeout, context=ctx) else: self.http_conn = http_client.HTTPConnection(self.host, self.port, timeout=self.timeout) if self.authenticator: self.authenticator.add_auth(headers) self.http_conn.request(method, self.root + path, body, headers=headers) response = self.http_conn.getresponse() body = response.read() try: data = json.loads(body) except ValueError: data = body if response.status in [401, 403]: raise errors.AuthenticationError() elif response.status == 500: raise errors.InternalServerError() elif response.status == 400: raise errors.BadRequestError(body) elif response.status == 404: raise errors.NotFoundError() return (response, data)
def fb_refresh_access_token(refresh_token, auth_settings): connection = http_client.HTTPSConnection('graph.facebook.com', 443) headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'} body = 'fb_exchange_token={0}&client_id={1}&client_secret={2}&redirect_uri={3}'.format(refresh_token, auth_settings['client_id'], auth_settings['client_secret'], auth_settings['redirect_uri']) connection.request('POST', '/v2.3/oauth/access_token', body, headers) response = connection.getresponse() if response.status == 200: response_data = json.loads(response.read()) fb_refresh_token_data = { 'access_token': response_data['access_token'], 'expires_in': response_data['expires_in'], 'refresh_token': response_data['refresh_token'] } return fb_refresh_token_data else: raise Exception(response.read())
def unmock_putrequest(conn, method, url, skip_host=False, skip_accept_encoding=False): """putrequest mock; called initially after the HTTPConnection object has been created. Contains information about the endpoint and method. :param conn :type conn HTTPConnection :param method :type method string :param url :type url string :param skip_host :type skip_host bool :param skip_accept_encoding :type skip_accept_encoding bool """ if unmock_options._is_host_whitelisted( conn.host): # Host is whitelisted, redirect to original call. original_putrequest(conn, method, url, skip_host, skip_accept_encoding) elif not hasattr(conn, "unmock"): # Otherwise, we create our own HTTPSConnection to redirect the call to our service when needed. # We add the "unmock" attribute to this object and store information for later use. uri = parse_url(url) req = http_client.HTTPSConnection(unmock_options._unmock_host, unmock_options._unmock_port, timeout=conn.timeout) setattr(req, "unmock_data", UnmockData(path=uri.path, query=uri.query, method=method)) if token is not None: # Add token to official headers # Added as a 1-tuple as the actual call to `putheader` (later on) unpacks it req.unmock_data.headers["Authorization"] = ( "Bearer {token}".format(token=token), ) ua_key, ua_value = unmock_user_agent() req.unmock_data.headers[ua_key] = (ua_value, ) setattr(conn, "unmock", req)
def __init__(self, url, user_credentials, ca_file=None): parsedurl = urlparse.urlparse(url) self._url = parsedurl.geturl() self._netloc = parsedurl.netloc self._ca_file = ca_file if parsedurl.scheme == 'https': if self._ca_file: self._connection = HTTPSConnectionWithCaVerification( self._netloc, ca_file=self._ca_file.name) else: self._connection = http_client.HTTPSConnection(self._netloc) LOG.warning( _LW("Will not verify the server certificate of the API service" " because the CA certificate is not available.")) else: self._connection = http_client.HTTPConnection(self._netloc) self._id = 0 self._fail_fast = True self._credentials = BasicAuthCredentials(user_credentials[0], user_credentials[1]) self._require_cert_verify = self._ca_file is not None self._disabled_cert_verification = False