@Override public String open(Job loadJob) { try { String builder = BASE_RESUMABLE_URI + options.getProjectId() + "/jobs"; GenericUrl url = new GenericUrl(builder); url.set("uploadType", "resumable"); JsonFactory jsonFactory = bigquery.getJsonFactory(); HttpRequestFactory requestFactory = bigquery.getRequestFactory(); HttpRequest httpRequest = requestFactory.buildPostRequest(url, new JsonHttpContent(jsonFactory, loadJob)); httpRequest.getHeaders().set("X-Upload-Content-Value", "application/octet-stream"); HttpResponse response = httpRequest.execute(); return response.getHeaders().getLocation(); } catch (IOException ex) { throw translate(ex); } }
private static String getAppEngineProjectIdFromMetadataServer() throws IOException { String metadata = "http://metadata.google.internal"; String projectIdURL = "/computeMetadata/v1/project/project-id"; GenericUrl url = new GenericUrl(metadata + projectIdURL); HttpTransport netHttpTransport = new NetHttpTransport(); HttpRequestFactory requestFactory = netHttpTransport.createRequestFactory(); HttpRequest request = requestFactory .buildGetRequest(url) .setConnectTimeout(500) .setReadTimeout(500) .setHeaders(new HttpHeaders().set("Metadata-Flavor", "Google")); HttpResponse response = request.execute(); return headerContainsMetadataFlavor(response) ? response.parseAsString() : null; }
private String requestRaw(String path) throws IOException { HttpRequest getRequest = TRANSPORT.createRequestFactory().buildGetRequest( new GenericUrl(baseUrl + path)); HttpHeaders headers = new HttpHeaders(); headers.setAuthorization("Bearer " + accessToken); getRequest.setHeaders(headers); HttpResponse response = getRequest.execute(); validateResponse(getRequest, response, 200); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); IOUtils.copy(response.getContent(), byteArrayOutputStream, true); return byteArrayOutputStream.toString(); }
private void delete(String url) { HttpHeaders headers = new HttpHeaders(); headers.setAccept("text/turtle"); headers.setCookie(authCookie); try { HttpRequest deleteRequest = factory.buildDeleteRequest(new GenericUrl(url)) .setThrowExceptionOnExecuteError(false); deleteRequest.setHeaders(headers); validateResponse(deleteRequest.execute(), 200); logger.debug("Deleted: {}", url); } catch (IOException e) { throw new IllegalStateException("Couldn't delete: " + url, e); } }
/** Posts an RDF model to a Solid server. **/ public String postContent( String url, String slug, String type, Model model) throws IOException { StringWriter stringWriter = new StringWriter(); model.write(stringWriter, "TURTLE"); HttpContent content = new ByteArrayContent("text/turtle", stringWriter.toString().getBytes()); HttpRequest postRequest = factory.buildPostRequest( new GenericUrl(url), content); HttpHeaders headers = new HttpHeaders(); headers.setCookie(authCookie); headers.set("Link", "<" + type + ">; rel=\"type\""); headers.set("Slug", slug); postRequest.setHeaders(headers); HttpResponse response = postRequest.execute(); validateResponse(response, 201); return response.getHeaders().getLocation(); }
private String getSignature(String bytes) throws IOException { String signBlobUrl = String.format(SIGN_BLOB_URL_FORMAT, getAccount()); GenericUrl genericUrl = new GenericUrl(signBlobUrl); HttpRequest request = transportFactory.create().createRequestFactory().buildPostRequest(genericUrl, signContent); Map<String, List<String>> headers = getRequestMetadata(); HttpHeaders requestHeaders = request.getHeaders(); for (Map.Entry<String, List<String>> entry : headers.entrySet()) { requestHeaders.put(entry.getKey(), entry.getValue()); request.setParser(parser); request.setThrowExceptionOnExecuteError(false); HttpResponse response = request.execute(); int statusCode = response.getStatusCode(); if (statusCode >= 400 && statusCode < HttpStatusCodes.STATUS_CODE_SERVER_ERROR) { GenericData responseError = response.parseAs(GenericData.class); Map<String, Object> error = OAuth2Utils.validateMap(responseError, "error", PARSE_ERROR_MESSAGE); String errorMessage = OAuth2Utils.validateString(error, "message", PARSE_ERROR_MESSAGE); response.parseAsString())); InputStream content = response.getContent();
try { Insert req = storage.objects().insert(object.getBucket(), object); GenericUrl url = req.buildHttpRequest().getUrl(); String scheme = url.getScheme(); String host = url.getHost(); int port = url.getPort(); HttpRequestFactory requestFactory = storage.getRequestFactory(); HttpRequest httpRequest = requestFactory.buildPostRequest(url, new JsonHttpContent(jsonFactory, object)); HttpHeaders requestHeaders = httpRequest.getHeaders(); requestHeaders.set( "X-Upload-Content-Type", firstNonNull(object.getContentType(), "application/octet-stream")); BaseEncoding base64 = BaseEncoding.base64(); HashFunction hashFunction = Hashing.sha256(); requestHeaders.set("x-goog-encryption-algorithm", "AES256"); requestHeaders.set("x-goog-encryption-key", key); requestHeaders.set( "x-goog-encryption-key-sha256", base64.encode(hashFunction.hashBytes(base64.decode(key)).asBytes())); return response.getHeaders().getLocation(); } catch (IOException ex) { span.setStatus(Status.UNKNOWN.withDescription(ex.getMessage()));
"https://www.googleapis.com/bigquery/v2/projects/%s/datasets/%s" + "?fields=labels&access_token=%s"; GenericUrl url = new GenericUrl(String.format(urlFormat, projectId, datasetId, accessToken)); HttpRequestFactory requestFactory = HTTP_TRANSPORT.createRequestFactory(); HttpRequest request = requestFactory.buildPostRequest(url, content); request.setParser(JSON_FACTORY.createJsonObjectParser()); request.setHeaders(new HttpHeaders().set("X-HTTP-Method-Override", "PATCH")); HttpResponse response = request.execute(); if (response.getStatusCode() != 200) { throw new RuntimeException(response.getStatusMessage()); Dataset responseDataset = response.parseAs(Dataset.class); System.out.printf( "Updated label \"%s\" with value \"%s\"\n",
@Override protected TokenResponse executeRefreshToken() throws IOException { GenericUrl tokenUrl = new GenericUrl(getTokenServerEncodedUrl()); HttpRequest request = getTransport().createRequestFactory().buildGetRequest(tokenUrl); request.setParser(new JsonObjectParser(getJsonFactory())); request.getHeaders().set("Metadata-Flavor", "Google"); return request.execute().parseAs(TokenResponse.class); }
@Nullable private static String queryProjectIdFromComputeEngine() { HttpTransport transport; try { transport = newTransport(); } catch (GeneralSecurityException | IOException e) { logger.log(Level.WARNING, "Failed to create HttpTransport.", e); return null; } try { GenericUrl projectIdUrl = new GenericUrl("http://metadata/computeMetadata/v1/project/project-id"); HttpRequest request = transport.createRequestFactory().buildGetRequest(projectIdUrl); request.getHeaders().set("Metadata-Flavor", "Google"); String result = request.execute().parseAsString(); projectIdFromComputeEngine.set(result); return result; } catch (IOException e) { logger.log(Level.INFO, "Could not determine project ID from Compute Engine.", e); return null; } }
/** * Parses the contents of a URL to produce an RDF model. */ public Model getModel(String url) throws IOException { HttpRequestFactory factory = TRANSPORT.createRequestFactory(); HttpRequest rootGetRequest = factory.buildGetRequest( new GenericUrl(url)); HttpHeaders headers = new HttpHeaders(); headers.setCookie(authCookie); headers.setAccept("text/turtle"); rootGetRequest.setHeaders(headers); HttpResponse response = rootGetRequest.execute(); if (response.getStatusCode() != 200) { throw new IOException("Unexpected return code: " + response.getStatusCode() + "\nMessage:\n" + response.getStatusMessage()); } StringWriter writer = new StringWriter(); IOUtils.copy(response.getContent(), writer, "UTF-8"); String fixedString = fixProblematicPeriods(writer.toString()); Model defaultModel = ModelFactory.createDefaultModel(); return defaultModel.read( new StringReader(fixedString), url, "TURTLE"); }
rpcCount.incrementAndGet(); ProtoHttpContent payload = new ProtoHttpContent(request); HttpRequest httpRequest = client.buildPostRequest(resolveURL(methodName), payload); httpRequest.getHeaders().put(API_FORMAT_VERSION_HEADER, API_FORMAT_VERSION); httpRequest.setThrowExceptionOnExecuteError(false); if (initializer != null) { initializer.initialize(httpRequest); httpResponse = httpRequest.execute(); if (!httpResponse.isSuccessStatusCode()) { throw makeException(url, methodName, httpResponse.getContent(), httpResponse.getContentType(), httpResponse.getContentCharset(), null, httpResponse.getStatusCode());
private String makeCall(HttpTransport transport) throws IOException { HttpRequest get = transport.createRequestFactory() .buildPostRequest(new GenericUrl(INRPUT_LOGIN_SERVER), null) .setFollowRedirects(false) .setThrowExceptionOnExecuteError(false); HttpResponse response = get.execute(); if (response.getStatusCode() != 302) { throw new IOException("Unexpected return code: " + response.getStatusCode() + "\nMessage:\n" + response.getStatusMessage()); } String cookieValue = response.getHeaders().getFirstHeaderStringValue("set-cookie"); if (Strings.isNullOrEmpty(cookieValue)) { throw new IOException("Couldn't extract cookie value from headers: " + response.getHeaders()); } return cookieValue; } }
httpTransport.createRequestFactory( req -> { HttpHeaders headers = createHttpHeaders(); headers.setContentLength(0L); headers.set("x-goog-resumable", "start"); req.setHeaders(headers); req.setLoggingEnabled(true); }); requestFactory.buildPostRequest(new GenericUrl(batchJobUploadUrl), new EmptyContent()); HttpResponse response = httpRequest.execute(); if (response.getHeaders() == null || response.getHeaders().getLocation() == null) { throw new BatchJobException( "Initiate upload failed. Resumable upload URI was not in the response."); return URI.create(response.getHeaders().getLocation()); } catch (IOException e) { throw new BatchJobException("Failed to initiate upload", e);
/** Posts a new status for the user, initially marked as private.**/ public void postStatus(String content, String idempotencyKey) throws IOException { ImmutableMap<String, String> formParams = ImmutableMap.of( "status", content, // Default everything to private to avoid a privacy incident "visibility", "private" ); UrlEncodedContent urlEncodedContent = new UrlEncodedContent(formParams); HttpRequest postRequest = TRANSPORT.createRequestFactory() .buildPostRequest( new GenericUrl(baseUrl + POST_URL), urlEncodedContent) .setThrowExceptionOnExecuteError(false); HttpHeaders headers = new HttpHeaders(); headers.setAuthorization("Bearer " + accessToken); if (!Strings.isNullOrEmpty(idempotencyKey)) { // This prevents the same post from being posted twice in the case of network errors headers.set("Idempotency-Key", idempotencyKey); } postRequest.setHeaders(headers); HttpResponse response = postRequest.execute(); validateResponse(postRequest, response, 200); }
mockHttpServer .getHttpTransport() .createRequestFactory() .buildGetRequest(new GenericUrl(mockHttpServer.getServerUrl())); String requestContent = "test request"; request.setContent(new ByteArrayContent("text", requestContent.getBytes(UTF_8))); HttpResponse response = request.execute(); ActualResponse actualResponse = mockHttpServer.getAllResponses().get(i); assertEquals(200, response.getStatusCode()); assertEquals( "Response contents incorrect", expectedResponses.get(i).getBody(), Streams.readAll(response.getContent(), response.getContentCharset())); assertEquals( "Location header incorrect on response", mockHttpServer.getServerUrl(), response.getHeaders().getLocation()); assertFalse( "No gzip header passed, but request was compressed",
final HttpHeaders headers = new HttpHeaders(); final HttpRequest request; try { request = requestFactory.buildRequest(method.getName(), new GenericUrl(URI.create(uri)), null); } catch (IOException e) { throw Throwables.propagate(e); headers.setAuthorization("Bearer " + accessToken); headers.setUserAgent("Spotify"); final byte[] json = gzipJson(payload); payloadSize = json.length; headers.setContentEncoding(GZIP); headers.setContentLength((long) json.length); headers.setContentType(APPLICATION_JSON_UTF8); request.setContent(new ByteArrayContent(APPLICATION_JSON_UTF8, json)); } else { payloadSize = 0; request.setHeaders(headers); if (response.getStatusCode() == 404 && method == HttpMethod.GET || method == HttpMethod.DELETE) { future.succeed(null); return;
private HttpResponse getMetadataResponse(String url) throws IOException { GenericUrl genericUrl = new GenericUrl(url); HttpRequest request = transportFactory.create().createRequestFactory().buildGetRequest(genericUrl); JsonObjectParser parser = new JsonObjectParser(OAuth2Utils.JSON_FACTORY); request.setParser(parser); request.getHeaders().set("Metadata-Flavor", "Google"); request.setThrowExceptionOnExecuteError(false); HttpResponse response; try { response = request.execute(); } catch (UnknownHostException exception) { throw new IOException("ComputeEngineCredentials cannot find the metadata server. This is" + " likely because code is not running on Google Compute Engine.", exception); } return response; }
HttpRequestFactory requestFactory = httpTransport.createRequestFactory(googleCredentials); GenericUrl url = new GenericUrl(uri); HttpRequest request = requestFactory.buildPostRequest(url, new EmptyContent()); try { HttpResponse response = request.execute(); if (response.getStatusCode() == HttpStatusCodes.STATUS_CODE_OK) { return response.getHeaders().getLocation(); } else { LOGGER.severe("Could not get upload URL, HTTP code = " + response.getStatusCode());
protected static String uploadFile(String targetAppPath, String serverURL, String testDroidApiKey) throws IOException { final HttpHeaders headers = new HttpHeaders().setBasicAuthentication(testDroidApiKey, ""); HttpRequestFactory requestFactory = HTTP_TRANSPORT.createRequestFactory(request -> { request.setParser(new JsonObjectParser(JSON_FACTORY)); request.setHeaders(headers); }); MultipartFormDataContent multipartContent = new MultipartFormDataContent(); FileContent fileContent = new FileContent("application/octet-stream", new File(targetAppPath)); MultipartFormDataContent.Part filePart = new MultipartFormDataContent.Part("file", fileContent); multipartContent.addPart(filePart); HttpRequest request = requestFactory.buildPostRequest(new GenericUrl(serverURL+"/upload"), multipartContent); AppiumResponse appiumResponse = request.execute().parseAs(AppiumResponse.class); logger.info("File id:" + appiumResponse.uploadStatus.fileInfo.file); return appiumResponse.uploadStatus.fileInfo.file; }