def setUp(self): self.temp_dir = self._GenerateTestData() multiplexer = event_multiplexer.EventMultiplexer( size_guidance=application.DEFAULT_SIZE_GUIDANCE, purge_orphaned_data=True) plugins = {} app = application.TensorBoardWSGIApp(self.temp_dir, plugins, multiplexer, reload_interval=0) self._server = serving.BaseWSGIServer('localhost', 0, app) # 0 to pick an unused port. self._server_thread = threading.Thread( target=self._server.serve_forever) self._server_thread.daemon = True self._server_thread.start() self._connection = http_client.HTTPConnection( 'localhost', self._server.server_address[1])
def testDataPaths_disableAllCaching(self): """Test the format of the /data/runs endpoint.""" for path in ('/data/runs', '/data/logdir', '/data/scalars?run=run1&tag=simple_values', '/data/scalars?run=run1&tag=simple_values&format=csv', '/data/images?run=run1&tag=image', '/data/individualImage?run=run1&tag=image&index=0', '/data/audio?run=run1&tag=audio', '/data/run_metadata?run=run1&tag=test%20run'): connection = http_client.HTTPConnection( 'localhost', self._server.server_address[1]) connection.request('GET', path) response = connection.getresponse() self.assertEqual(response.status, 200, msg=path) self.assertEqual(response.getheader('Expires'), '0', msg=path) response.read() connection.close()
def __init__(self, uri_or_host, port=None, path=None, customThrift=False): """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
def _CreateDB(self): """This method is idempotent. If the DB already exists it will simply return a 200 code without re-creating it. """ successful_http_request_codes = [200, 202, 204] header = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'text/plain'} params = urllib.parse.urlencode( {'q': 'CREATE DATABASE ' + self.influx_db_name}) conn = httplib.HTTPConnection(self.influx_uri) conn.request('POST', '/query?' + params, headers=header) response = conn.getresponse() conn.close() if response.status in successful_http_request_codes: logging.debug('Success! %s DB Created', self.influx_db_name) else: logging.error('%d Request could not be completed due to: %s', response.status, response.reason) raise httplib.HTTPException
def check(self): conn = http_client.HTTPConnection('fw.telldus.com:80') try: conn.request( 'GET', "/versions.xml?mac=%s&hw=%s&product=%s" % (Board.getMacAddr(), self.hw(), Board.product())) response = conn.getresponse() except Exception as error: logging.warning("Could not get version info: %s", error) return False parser = xml.parsers.expat.ParserCreate() parser.StartElementHandler = self._startElement parser.EndElementHandler = self._endElement parser.CharacterDataHandler = self._characterDataHandler parser.Parse(response.read()) if self._url != '': return True return False
def _make_http_connection(init, mode, uri=None): """ Creates a HTTPConnection instance if the HTTP server supports Range requests, otherwise falls back to a generic InputStream. """ from six.moves import http_client parsed = urlparse.urlparse(init) connection = http_client.HTTPConnection(parsed.netloc) connection.connect() block_size = io.DEFAULT_BUFFER_SIZE # We request a range of the whole file ("0-") to check if the # server understands that header entry, and also to get the # size of the entire file headers = {'Range': 'bytes=0-'} connection.request('GET', parsed.path, headers=headers) response = connection.getresponse() if response.status // 100 != 2: raise IOError("HTTP failed: {0} {1}".format(response.status, response.reason)) # Status 206 means a range was returned. If it's anything else # that indicates the server probably doesn't support Range # headers. if (response.status != 206 or response.getheader('accept-ranges', None) != 'bytes' or response.getheader('content-range', None) is None or response.getheader('content-length', None) is None): # Fall back to a regular input stream, but we don't # need to open a new connection. response.close = connection.close return InputStream(response, mode, uri=uri or init, close=True) # Since we'll be requesting chunks, we can't read at all with the # current request (because we can't abort it), so just close and # start over size = int(response.getheader('content-length')) first_chunk = response.read(block_size) response.close() return HTTPConnection(connection, size, parsed.path, uri or init, first_chunk)
def wait_for_http_server(host, port, sleep_amount=0.1, sleep_tries=150): """Wait for an HTTP server to boot up.""" # Test if the server is up for i in range(sleep_tries): # directly test the app, not the proxy conn = http_client.HTTPConnection(host, port) try: conn.request("GET", "/") response = conn.getresponse() if response.status == 200: break except socket.error as e: if e.errno not in [61, 111]: raise time.sleep(sleep_amount) else: template = "Test HTTP server on host %s and port %s did not return '200 OK' after 10 tries" message = template % (host, port) raise Exception(message)
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 upload_to(host, filename, port=7777): """ Simple method to upload a file into NGAS """ with contextlib.closing(httplib.HTTPConnection(host, port)) as conn: conn.putrequest('POST', '/QARCHIVE?filename=%s' % ( urlparse.quote(os.path.basename(filename)),)) conn.putheader('Content-Length', os.stat(filename).st_size) conn.endheaders() with open(filename) as f: for data in iter(functools.partial(f.read, 4096), ''): conn.send(data) r = conn.getresponse() if r.status != httplib.OK: raise Exception("Error while QARCHIVE-ing %s to %s:%d:\nStatus: " "%d\n%s\n\n%s" % (filename, conn.host, conn.port, r.status, r.msg, r.read())) else: success("{0} successfully archived to {1}!".format(filename, host))
def replication_dump(options, args): """%(prog)s dump <server:port> <path> Dump the contents of a glance instance to local disk. server:port: the location of the glance instance. path: a directory on disk to contain the data. """ # Make sure server and path are provided if len(args) < 2: raise TypeError(_("Too few arguments.")) path = args.pop() server, port = utils.parse_valid_host_port(args.pop()) imageservice = get_image_service() client = imageservice(http_client.HTTPConnection(server, port), options.mastertoken) for image in client.get_images(): LOG.debug('Considering: %s' % image['id']) data_path = os.path.join(path, image['id']) if not os.path.exists(data_path): LOG.info(_LI('Storing: %s') % image['id']) # Dump glance information with open(data_path, 'w') as f: f.write(jsonutils.dumps(image)) if image['status'] == 'active' and not options.metaonly: # Now fetch the image. The metadata returned in headers here # is the same as that which we got from the detailed images # request earlier, so we can ignore it here. Note that we also # only dump active images. LOG.debug('Image %s is active' % image['id']) image_response = client.get_image(image['id']) with open(data_path + '.img', 'wb') as f: while True: chunk = image_response.read(options.chunksize) if not chunk: break f.write(chunk)
def request(self, method, bucket_name=None, url=None, headers=None, body=None, sub_resources=None): headers = HeaderDict() if headers is None else headers.copy() if 'x-amz-date' not in headers: headers['x-amz-date'] = \ datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S +0000') if self.iam_token is not None: self._refresh_iam_credentials() headers['x-amz-security-token'] = self.iam_token headers['Authorization'] = self.sign(method, bucket_name, url, headers, sub_resources) while True: try: if self.connection is None: self.connection = httplib.HTTPConnection(self.host) self.connection.request(method, url, body, headers) response = self.connection.getresponse() if response.status not in xrange(200, 300): raise S3Error(method, url, body, headers, response) headers = HeaderDict(response.getheaders()) body = response.read() return (headers, body) except httplib.BadStatusLine as exc: logger.warn(exc) self.connection = None except httplib.CannotSendRequest as exc: logger.warn(exc) self.connection = None except ssl.SSLError as exc: logger.warn(exc) self.connection = None except IOError as exc: if exc.errno == errno.ECONNRESET: logger.warn(exc) self.connection = None else: raise
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 _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 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 _account_request(self, account, method, headers=None): if headers is None: headers = {} headers['X-Auth-Token'] = self.token scheme, netloc, path, _, _, _ = urlparse(self.url) host, port = netloc.split(':') port = int(port) conn = http_client.HTTPConnection(host, port) conn.request(method, self._account_path(account), headers=headers) resp = conn.getresponse() if resp.status // 100 != 2: raise Exception("Unexpected status %s\n%s" % (resp.status, resp.read())) response_headers = dict(resp.getheaders()) response_body = resp.read() resp.close() return response_headers, response_body
def test_request_info_put(server): con = http_client.HTTPConnection("localhost", server.server_port) with closing(con): content = "it works!" con.request("PUT", "/request-info/arg", body=content.encode("utf-8")) r = con.getresponse() assert r.status == http.OK info = json.loads(r.read()) assert info["method"] == "PUT" assert info["uri"] == "/request-info/arg" assert info["path"] == "/request-info/arg" assert info["arg"] == "arg" assert info["query"] == {} assert info["version"] == "HTTP/1.1" assert info["content_length"] == len(content) assert info["content"] == content assert info["headers"]["accept-encoding"] == "identity" assert info["headers"]["content-length"] == str(len(content)) assert info["content_range"] is None
def test_request_info_get(server): con = http_client.HTTPConnection("localhost", server.server_port) with closing(con): con.request("GET", "/request-info/arg") r = con.getresponse() assert r.status == http.OK info = json.loads(r.read()) assert info["method"] == "GET" assert info["uri"] == "/request-info/arg" assert info["path"] == "/request-info/arg" assert info["arg"] == "arg" assert info["query"] == {} assert info["version"] == "HTTP/1.1" assert info["content_length"] is None assert info["content"] is None assert info["headers"]["host"] == "localhost:%d" % server.server_port assert info["headers"]["accept-encoding"] == "identity" assert info["client_addr"] == "127.0.0.1" assert info["range"] is None
def __connect_with_server(self, get_operatoin, server_reuest_type): """Function connect with server and downloades avaliable subtitle list or avaliable subtitle zip file """ what_is_downloaded = server_reuest_type self.XML_String = None self.zip_string = None try: conn = httplib.HTTPConnection(self.NAPISY24_url) conn.request("GET", get_operatoin) r1 = conn.getresponse() print(r1.status, r1.reason) if what_is_downloaded == "downloada_subtitle_list_by_film_name" or what_is_downloaded == "downloada_subtitle_list_by_IMDB": self.XML_String = r1.read() elif what_is_downloaded == "download_subtilte_zip": self.zip_string = r1.read() return r1.status #, r1.reason except (IOError, OSError) as e: print("Napisy24.pl server connection error.", file=sys.stderr) time.sleep(0.5)
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 main(unused_argv=None): target = FLAGS.target logdir = FLAGS.logdir if not target or not logdir: PrintAndLog('Both --target and --logdir are required.', tf.logging.ERROR) return -1 if os.path.exists(target): if FLAGS.overwrite: if os.path.isdir(target): shutil.rmtree(target) else: os.remove(target) else: PrintAndLog( 'Refusing to overwrite target %s without --overwrite' % target, tf.logging.ERROR) return -2 path_to_run = server.ParseEventFilesSpec(FLAGS.logdir) PrintAndLog('About to load Multiplexer. This may take some time.') multiplexer = event_multiplexer.EventMultiplexer( size_guidance=server.TENSORBOARD_SIZE_GUIDANCE, purge_orphaned_data=FLAGS.purge_orphaned_data) server.ReloadMultiplexer(multiplexer, path_to_run) PrintAndLog('Multiplexer load finished. Starting TensorBoard server.') s = server.BuildServer(multiplexer, 'localhost', 0) server_thread = threading.Thread(target=s.serve_forever) server_thread.daemon = True server_thread.start() connection = http_client.HTTPConnection('localhost', s.server_address[1]) PrintAndLog('Server setup! Downloading data from the server.') x = TensorBoardStaticSerializer(connection, target) x.Run() PrintAndLog('Done downloading data.') connection.close() s.shutdown() s.server_close()
def _check_reload(self, server_name, ip, port): manager = Manager([server_name]) manager.start() starting_pids = set(pid for server in manager.servers for (_, pid) in server.iter_pid_files()) body = 'test' * 10 conn = httplib.HTTPConnection('%s:%s' % (ip, port)) # sanity request putrequest(conn, 'PUT', 'blah', headers={'Content-Length': len(body)}) conn.send(body) resp = conn.getresponse() self.assertEqual(resp.status // 100, 4) resp.read() manager.reload() post_reload_pids = set(pid for server in manager.servers for (_, pid) in server.iter_pid_files()) # none of the pids we started with are being tracked after reload msg = 'expected all pids from %r to have died, but found %r' % ( starting_pids, post_reload_pids) self.assertFalse(starting_pids & post_reload_pids, msg) # ... and yet we can keep using the same connection! putrequest(conn, 'PUT', 'blah', headers={'Content-Length': len(body)}) conn.send(body) resp = conn.getresponse() self.assertEqual(resp.status // 100, 4) resp.read() # close our connection conn.close() # sanity post_close_pids = set(pid for server in manager.servers for (_, pid) in server.iter_pid_files()) self.assertEqual(post_reload_pids, post_close_pids)
def _connect(self): ''' Initialize an HTTP connection with chunked Transfer-Encoding to server:port with optional headers. ''' server = self._server port = self._port headers = self._headers 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_appliance_template(request, pk): logger.info('Getting and displaying YAML template for appliance') appliance = Appliance.objects.filter(pk=pk).get() # send message to GA if settings.GOOGLE_ANALYTICS_PROPERTY_ID: try: params = urllib.parse.urlencode({'v': 1, 'tid': settings.GOOGLE_ANALYTICS_PROPERTY_ID, 'cid': uuid.uuid1(), 't': 'event', 'ec': 'heat_template', 'ea': 'download', 'el': '{}-{}'.format(pk, appliance.name), 'ev': 0}) conn = http_client.HTTPConnection('www.google-analytics.com') conn.request('POST', '/collect', params) except: logger.exception("Failed to report to Google Analytics") return HttpResponse(appliance.template, content_type="text/yaml")
def get_public_ip(): """Return the IP address that outgoing network connections appear to come from. This is also the IP address to use for inbound access. Note that in addition, an supplied service with the "external" flag set needs to be defined in Ravello. """ # This uses ipify.org. See www.ipify.org. This is a free service running # open source code deployed on Heroku. ON the web site the author says he # intends to keep it around for years to come. conn = http_client.HTTPConnection('api.ipify.org', 80) try: conn.request('GET', '/') resp = conn.getresponse() if resp.status != http_client.OK: raise RuntimeError('api.ipify.org status {}'.format(resp.status)) body = resp.read() finally: conn.close() return body
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 _request(self, url, method, content=None, headers={}): # Do the HTTP stuff... logger.debug("Sending %s request to %s:%d%s", method, self.host, self.port, url) if not utils.portIsOpen(self.host, self.port, self.timeout): raise RestClientException( "Cannot connect to %s:%d after %.2f [s]" % (self.host, self.port, self.timeout)) if content and hasattr(content, 'read'): headers['Transfer-Encoding'] = 'chunked' content = chunked(content) self._conn = httplib.HTTPConnection(self.host, self.port) self._conn.request(method, url, content, headers) self._resp = self._conn.getresponse() # Server errors are encoded in the body as json content if self._resp.status != httplib.OK: msg = 'Error on remote %s@%s:%s%s (status %d): ' % \ (method, self.host, self.port, url, self._resp.status) try: error = json.loads(self._resp.read().decode('utf-8')) etype = getattr(exceptions, error['type']) eargs = error['args'] ex = etype(*eargs) if hasattr(ex, 'msg'): ex.msg = msg + ex.msg except Exception: ex = RestClientException(msg + "Unknown") raise ex if not self._resp.length: return None return codecs.getreader('utf-8')(self._resp)
def DoesUrlExist(url): """Determines whether a resource exists at the given URL. Args: url: URL to be verified. Returns: True if url exists, otherwise False. """ parsed = urllib.parse.urlparse(url) try: conn = http_client.HTTPConnection(parsed.netloc) conn.request('HEAD', parsed.path) response = conn.getresponse() except http_client.HTTPException: return False finally: conn.close() # Follow both permanent (301) and temporary (302) redirects. if response.status == 302 or response.status == 301: return DoesUrlExist(response.getheader('location')) return response.status == 200
def make_request(conn, method, resource, parameters=None, sign_parameters=False, extra_parameters=None): """generic request sending to pubsub radogw should cover: topics, notificatios and subscriptions """ url_params = '' if parameters is not None: url_params = urlparse.urlencode(parameters) # remove 'None' from keys with no values url_params = url_params.replace('=None', '') url_params = '?' + url_params if extra_parameters is not None: url_params = url_params + '&' + extra_parameters string_date = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime()) string_to_sign = method + '\n\n\n' + string_date + '\n' + resource if sign_parameters: string_to_sign += url_params signature = base64.b64encode( hmac.new(conn.aws_secret_access_key.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha1).digest()).decode('ascii') headers = { 'Authorization': 'AWS ' + conn.aws_access_key_id + ':' + signature, 'Date': string_date, 'Host': conn.host + ':' + str(conn.port) } http_conn = http_client.HTTPConnection(conn.host, conn.port) if log.getEffectiveLevel() <= 10: http_conn.set_debuglevel(5) http_conn.request(method, resource + url_params, NO_HTTP_BODY, headers) response = http_conn.getresponse() data = response.read() status = response.status http_conn.close() return data.decode('utf-8'), status
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
def setUp(self): self.temp_dir = self._GenerateTestData() multiplexer = event_multiplexer.EventMultiplexer( size_guidance=application.DEFAULT_SIZE_GUIDANCE, purge_orphaned_data=True) plugins = [ FakePlugin(plugin_name='foo', is_active_value=True, routes_mapping={}), FakePlugin(plugin_name='bar', is_active_value=False, routes_mapping={}) ] app = application.TensorBoardWSGIApp( self.temp_dir, plugins, multiplexer, reload_interval=0) try: self._server = serving.BaseWSGIServer('localhost', 0, app) # 0 to pick an unused port. except IOError: # BaseWSGIServer has a preference for IPv4. If that didn't work, try again # with an explicit IPv6 address. self._server = serving.BaseWSGIServer('::1', 0, app) self._server_thread = threading.Thread(target=self._server.serve_forever) self._server_thread.daemon = True self._server_thread.start() self._connection = http_client.HTTPConnection( 'localhost', self._server.server_address[1])