/** * Gets an input stream to an image, given its URL. */ public InputStream get(String urlStr) throws IOException { URL url = new URL(urlStr); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.connect(); return conn.getInputStream(); } }
public HttpURLConnection connectToEndpoint(URI endpoint, Map<String, String> headers) throws IOException { HttpURLConnection connection = (HttpURLConnection) endpoint.toURL().openConnection(Proxy.NO_PROXY); connection.setConnectTimeout(1000 * 2); connection.setReadTimeout(1000 * 5); connection.setRequestMethod("GET"); connection.setDoOutput(true); for (Map.Entry<String, String> header : headers.entrySet()) { connection.addRequestProperty(header.getKey(), header.getValue()); } // TODO should we autoredirect 3xx // connection.setInstanceFollowRedirects(false); connection.connect(); return connection; }
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException { try { if (this.body != null) { this.body.close(); } else { SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers); this.connection.connect(); // Immediately trigger the request in a no-output scenario as well this.connection.getResponseCode(); } } catch (IOException ex) { // ignore } return new SimpleClientHttpResponse(this.connection); }
public static JsonObject getContent() throws IOException { URL url = new URL("http://localhost:8080"); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.connect(); InputStreamReader in = new InputStreamReader((InputStream) conn.getContent()); BufferedReader buff = new BufferedReader(in); String line; StringBuilder builder = new StringBuilder(); do { line = buff.readLine(); builder.append(line).append("\n"); } while (line != null); buff.close(); return new JsonObject(builder.toString()); }
/** * This method initiates a connect call of the provided connection and returns the response * stream. It only returns the error stream if it is available and readErrorStreamNoException is * true otherwise it throws an IOException if an error happens. Furthermore it wraps the stream * to decompress it if the connection content encoding is specified. */ public InputStream fetch(HttpURLConnection connection, boolean readErrorStreamNoException) throws IOException { // create connection but before reading get the correct inputstream based on the compression and if error connection.connect(); InputStream is; if (readErrorStreamNoException && connection.getResponseCode() >= 400 && connection.getErrorStream() != null) is = connection.getErrorStream(); else is = connection.getInputStream(); if (is == null) throw new IOException("Stream is null. Message:" + connection.getResponseMessage()); // wrap try { String encoding = connection.getContentEncoding(); if (encoding != null && encoding.equalsIgnoreCase("gzip")) is = new GZIPInputStream(is); else if (encoding != null && encoding.equalsIgnoreCase("deflate")) is = new InflaterInputStream(is, new Inflater(true)); } catch (IOException ex) { } return is; }
@SuppressWarnings("WeakerAccess") protected void writeContent(@NonNull HttpURLConnection connection, @NonNull Method method, @NonNull T content) throws IOException { // write output - see http://developer.android.com/reference/java/net/HttpURLConnection.html connection.setRequestMethod(method.name()); connection.setDoOutput(true); // Disable ConnectionPooling because otherwise OkHttp ConnectionPool will try to start a Thread on #connect System.setProperty("http.keepAlive", "false"); connection.connect(); final OutputStream outputStream = senderConfiguration.compress() ? new GZIPOutputStream(connection.getOutputStream(), ACRAConstants.DEFAULT_BUFFER_SIZE_IN_BYTES) : new BufferedOutputStream(connection.getOutputStream()); try { write(outputStream, content); outputStream.flush(); } finally { IOUtils.safeClose(outputStream); } }
private InputStream getImageAsStream(String urlStr) throws IOException { URL url = new URL(urlStr); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.connect(); return conn.getInputStream(); } }
/** * Connects to the metadata service to read the specified resource and * returns the text contents. * * @param resourcePath * The resource * * @return The text payload returned from the Amazon EC2 Instance Metadata * service for the specified resource path. * * @throws IOException * If any problems were encountered while connecting to metadata * service for the requested resource path. * @throws SdkClientException * If the requested metadata service is not found. */ public String readResource(String resourcePath) throws IOException, SdkClientException { URL url = getEc2MetadataServiceUrlForResource(resourcePath); log.debug("Connecting to EC2 instance metadata service at URL: " + url.toString()); HttpURLConnection connection = (HttpURLConnection)url.openConnection(); connection.setConnectTimeout(1000 * 2); connection.setReadTimeout(1000 * 5); connection.setRequestMethod("GET"); connection.setDoOutput(true); connection.addRequestProperty("User-Agent", USER_AGENT); connection.connect(); return readResponse(connection); }
@Override public ClientHttpResponse call() throws Exception { try { if (body != null) { body.close(); } else { SimpleBufferingClientHttpRequest.addHeaders(connection, headers); connection.connect(); // Immediately trigger the request in a no-output scenario as well connection.getResponseCode(); } } catch (IOException ex) { // ignore } return new SimpleClientHttpResponse(connection); } });
/** * Gets an input stream to an image, given its URL. Used by {@link FlickrPhotosImporter} to * upload the image. */ public BufferedInputStream get(String urlStr) throws IOException { URL url = new URL(urlStr); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.connect(); return new BufferedInputStream(conn.getInputStream()); } }
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException { try { if (this.body != null) { this.body.close(); } else { SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers); this.connection.connect(); // Immediately trigger the request in a no-output scenario as well this.connection.getResponseCode(); } } catch (IOException ex) { // ignore } return new SimpleClientHttpResponse(this.connection); }
public boolean checkStatus(URL serverURL) { try { // 1. Set up the connection HttpURLConnection connection = (HttpURLConnection) serverURL.openConnection(); // 1.1 Set authentication if (apiKey != null && apiSecret != null) { String userpass = apiKey + ':' + apiSecret; String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes())); connection.setRequestProperty("Authorization", basicAuth); } connection.setRequestMethod("GET"); connection.connect(); return connection.getResponseCode() >= 200 && connection.getResponseCode() <= 400; } catch (Throwable t) { throw new RuntimeException(t); } }
@Override public ClientHttpResponse call() throws Exception { try { if (body != null) { body.close(); } else { SimpleBufferingClientHttpRequest.addHeaders(connection, headers); connection.connect(); // Immediately trigger the request in a no-output scenario as well connection.getResponseCode(); } } catch (IOException ex) { // ignore } return new SimpleClientHttpResponse(connection); } });
/** Downloads the content of the specified url to the array. The array has to be big enough. */ private int download (byte[] out, String url) { InputStream in = null; try { HttpURLConnection conn = null; conn = (HttpURLConnection)new URL(url).openConnection(); conn.setDoInput(true); conn.setDoOutput(false); conn.setUseCaches(true); conn.connect(); in = conn.getInputStream(); int readBytes = 0; while (true) { int length = in.read(out, readBytes, out.length - readBytes); if (length == -1) break; readBytes += length; } return readBytes; } catch (Exception ex) { return 0; } finally { StreamUtils.closeQuietly(in); } }
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException { addHeaders(this.connection, headers); // JDK <1.8 doesn't support getOutputStream with HTTP DELETE if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) { this.connection.setDoOutput(false); } if (this.connection.getDoOutput() && this.outputStreaming) { this.connection.setFixedLengthStreamingMode(bufferedOutput.length); } this.connection.connect(); if (this.connection.getDoOutput()) { FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream()); } else { // Immediately trigger the request in a no-output scenario as well this.connection.getResponseCode(); } return new SimpleClientHttpResponse(this.connection); }
/** * If the first URL we try to access with a HTTP proxy is HTTPS then the authentication cache will not have been * pre-populated, so we try to access at least one HTTP URL before the very first HTTPS url. * @param proxy * @param url the actual URL being opened. */ private void jenkins48775workaround(Proxy proxy, URL url) { if ("https".equals(url.getProtocol()) && !authCacheSeeded && proxy != Proxy.NO_PROXY) { HttpURLConnection preAuth = null; try { // We do not care if there is anything at this URL, all we care is that it is using the proxy preAuth = (HttpURLConnection) new URL("http", url.getHost(), -1, "/").openConnection(proxy); preAuth.setRequestMethod("HEAD"); preAuth.connect(); } catch (IOException e) { // ignore, this is just a probe we don't care at all } finally { if (preAuth != null) { preAuth.disconnect(); } } authCacheSeeded = true; } else if ("https".equals(url.getProtocol())){ // if we access any http url using a proxy then the auth cache will have been seeded authCacheSeeded = authCacheSeeded || proxy != Proxy.NO_PROXY; } }
@Override public ClientHttpResponse call() throws Exception { SimpleBufferingClientHttpRequest.addHeaders(connection, headers); // JDK <1.8 doesn't support getOutputStream with HTTP DELETE if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) { connection.setDoOutput(false); } if (connection.getDoOutput() && outputStreaming) { connection.setFixedLengthStreamingMode(bufferedOutput.length); } connection.connect(); if (connection.getDoOutput()) { FileCopyUtils.copy(bufferedOutput, connection.getOutputStream()); } else { // Immediately trigger the request in a no-output scenario as well connection.getResponseCode(); } return new SimpleClientHttpResponse(connection); } });
public static Drawable drawableFromUrl(Context context, String url) throws IOException { Bitmap x; HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection(); connection.connect(); InputStream input = connection.getInputStream(); x = BitmapFactory.decodeStream(input); return new BitmapDrawable(context.getResources(), x); }
/** * @param threadId id of the calling thread * @param conn Opens and establish the communication * @throws IOException if an error occurred connecting to the server. * @throws HttpError if the HTTP Status-Code is not satisfiable */ void establishConnection(int threadId, HttpURLConnection conn) throws IOException, HttpError { conn.connect(); int statusCode = conn.getResponseCode(); if (DEBUG) { Log.d(TAG, threadId + ":Content-Length=" + conn.getContentLength() + " Code:" + statusCode); } switch (statusCode) { case 204: case 205: case 207: throw new HttpError(conn.getResponseCode()); case 416: return;// let the download thread handle this error default: if (statusCode < 200 || statusCode > 299) { throw new HttpError(statusCode); } } }
public static String getFromHTTP(String url, Time timeout) throws Exception { final URL u = new URL(url); LOG.info("Accessing URL " + url + " as URL: " + u); final long deadline = timeout.toMilliseconds() + System.currentTimeMillis(); while (System.currentTimeMillis() <= deadline) { HttpURLConnection connection = (HttpURLConnection) u.openConnection(); connection.setConnectTimeout(100000); connection.connect(); if (Objects.equals(HttpResponseStatus.SERVICE_UNAVAILABLE, HttpResponseStatus.valueOf(connection.getResponseCode()))) { // service not available --> Sleep and retry LOG.debug("Web service currently not available. Retrying the request in a bit."); Thread.sleep(100L); } else { InputStream is; if (connection.getResponseCode() >= 400) { // error! LOG.warn("HTTP Response code when connecting to {} was {}", url, connection.getResponseCode()); is = connection.getErrorStream(); } else { is = connection.getInputStream(); } return IOUtils.toString(is, ConfigConstants.DEFAULT_CHARSET); } } throw new TimeoutException("Could not get HTTP response in time since the service is still unavailable."); }