#5242

Committed 05 Aug 2024 01:49PM UTC coverage: 77.081% (-0.008%) from 77.089%

Build # #5242

Build Type

push

Committed by

Commit Message

[DCJ-400-maven]: Bump the maven-dependencies group with 6 updates (#2370)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

10029 of 13011 relevant lines covered (77.08%)

0.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.71

/src/main/java/org/broadinstitute/consent/http/util/HttpClientUtil.java

package org.broadinstitute.consent.http.util;

import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.SharedMetricRegistries;
import com.codahale.metrics.Timer;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpContent;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpResponse;
import com.google.api.client.http.HttpStatusCodes;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import jakarta.ws.rs.BadRequestException;
import jakarta.ws.rs.ForbiddenException;
import jakarta.ws.rs.NotAuthorizedException;
import jakarta.ws.rs.NotFoundException;
import jakarta.ws.rs.ServerErrorException;
import jakarta.ws.rs.core.MediaType;
import java.io.IOException;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.apache.commons.io.IOUtils;
import org.apache.hc.client5.http.classic.HttpClient;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.broadinstitute.consent.http.configurations.ServicesConfiguration;
import org.broadinstitute.consent.http.exceptions.ConsentConflictException;
import org.broadinstitute.consent.http.models.AuthUser;

public class HttpClientUtil implements ConsentLogger {

  public record SimpleResponse(int code, String entity) {

  }

  private final ServicesConfiguration configuration;

  private final LoadingCache<URI, SimpleResponse> cache;

  private final HttpClient httpClient;

  public HttpClientUtil(ServicesConfiguration configuration) {
    this.configuration = configuration;
    httpClient = HttpClients.createDefault();
    CacheLoader<URI, SimpleResponse> loader = new CacheLoader<>() {
      @Override
      public SimpleResponse load(URI uri) throws Exception {
        return getHttpResponse(new HttpGet(uri));
      }
    };
    this.cache = CacheBuilder
        .newBuilder()
        .expireAfterWrite(configuration.getCacheExpireMinutes(), TimeUnit.MINUTES)
        .build(loader);
  }

  /**
   * This returns the result of previously executed GET requests from a cache or executes them if
   * they are not yet cached.
   *
   * @param request The HttpGet request
   * @return SimpleResponse
   * @throws IOException The exception
   */
  public SimpleResponse getCachedResponse(HttpGet request) throws IOException {
    try {
      return cache.get(request.getUri());
    } catch (Exception e) {
      // Something went wrong with the cached version, log for followup
      logWarn(e.getMessage());
      return getHttpResponse(request);
    }
  }

  /**
   * This handles GET requests that could be subject to connection timeout errors by limiting the
   * request to a configured default number of seconds.
   *
   * @param request The HttpGet request
   * @return SimpleResponse
   * @throws IOException The exception
   */
  public SimpleResponse getHttpResponse(HttpGet request) throws IOException {
    final ScheduledExecutorService executor = Executors.newScheduledThreadPool(
        configuration.getPoolSize());
    executor.schedule(request::cancel, configuration.getTimeoutSeconds(), TimeUnit.SECONDS);
    return httpClient.execute(request, httpResponse ->
        new SimpleResponse(
            httpResponse.getCode(),
            IOUtils.toString(httpResponse.getEntity().getContent(), Charset.defaultCharset()))
    );
  }

  public HttpRequest buildGetRequest(GenericUrl genericUrl, AuthUser authUser) throws Exception {
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory().buildGetRequest(genericUrl);
    request.setHeaders(buildHeaders(authUser));
    return request;
  }

  public HttpRequest buildUnAuthedGetRequest(GenericUrl genericUrl) throws Exception {
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory().buildGetRequest(genericUrl);
    request.setHeaders(new HttpHeaders().set("X-App-ID", "DUOS"));
    return request;
  }

  public HttpRequest buildPostRequest(GenericUrl genericUrl, HttpContent content, AuthUser authUser)
      throws Exception {
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory().buildPostRequest(genericUrl, content);
    request.setHeaders(buildHeaders(authUser));
    return request;
  }

  public HttpRequest buildPutRequest(GenericUrl genericUrl, HttpContent content, AuthUser authUser)
      throws Exception {
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory().buildPutRequest(genericUrl, content);
    request.setHeaders(buildHeaders(authUser));
    return request;
  }

  public HttpRequest buildUnAuthedPostRequest(GenericUrl genericUrl, HttpContent content)
      throws Exception {
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory().buildPostRequest(genericUrl, content);
    request.setHeaders(new HttpHeaders().set("X-App-ID", "DUOS"));
    return request;
  }

  public HttpResponse handleHttpRequest(HttpRequest request) {
    String timerName = String.format("org.broadinstitute.consent.http.util.HttpClientUtil-%s-%s",
        request.getRequestMethod(), request.getUrl().toString());
    if (SharedMetricRegistries.tryGetDefault() == null) {
      logWarn("Default SharedMetricRegistries is null, setting default");
      SharedMetricRegistries.setDefault("org.broadinstitute.consent", new MetricRegistry());
    }
    Timer timer = SharedMetricRegistries.getDefault().timer(timerName);
    try {
      request.setThrowExceptionOnExecuteError(false);
      HttpResponse response;
      try (Timer.Context context = timer.time()) {
        response = request.execute();
        context.stop();
      }
      if (response != null) {
        return switch (response.getStatusCode()) {
          case HttpStatusCodes.STATUS_CODE_BAD_REQUEST ->
              throw new BadRequestException(response.getStatusMessage());
          case HttpStatusCodes.STATUS_CODE_UNAUTHORIZED ->
              throw new NotAuthorizedException(response.getStatusMessage());
          case HttpStatusCodes.STATUS_CODE_FORBIDDEN ->
              throw new ForbiddenException(response.getStatusMessage());
          case HttpStatusCodes.STATUS_CODE_NOT_FOUND ->
              throw new NotFoundException(response.getStatusMessage());
          case HttpStatusCodes.STATUS_CODE_CONFLICT ->
              throw new ConsentConflictException(response.getStatusMessage());
          default -> response;
        };
      }
    } catch (IOException e) {
      throw new ServerErrorException("Server Error (" + e.getMessage() + ")", HttpStatusCodes.STATUS_CODE_SERVER_ERROR);
    }
    throw new ServerErrorException("Server Error", HttpStatusCodes.STATUS_CODE_SERVER_ERROR);
  }

  private HttpHeaders buildHeaders(AuthUser authUser) {
    return new HttpHeaders()
        .setAuthorization("Bearer " + authUser.getAuthToken())
        .setAccept(MediaType.APPLICATION_JSON)
        .set("X-App-ID", "DUOS");
  }
}

1	package org.broadinstitute.consent.http.util;
2
3	import com.codahale.metrics.MetricRegistry;
4	import com.codahale.metrics.SharedMetricRegistries;
5	import com.codahale.metrics.Timer;
6	import com.google.api.client.http.GenericUrl;
7	import com.google.api.client.http.HttpContent;
8	import com.google.api.client.http.HttpHeaders;
9	import com.google.api.client.http.HttpRequest;
10	import com.google.api.client.http.HttpResponse;
11	import com.google.api.client.http.HttpStatusCodes;
12	import com.google.api.client.http.HttpTransport;
13	import com.google.api.client.http.javanet.NetHttpTransport;
14	import com.google.common.cache.CacheBuilder;
15	import com.google.common.cache.CacheLoader;
16	import com.google.common.cache.LoadingCache;
17	import jakarta.ws.rs.BadRequestException;
18	import jakarta.ws.rs.ForbiddenException;
19	import jakarta.ws.rs.NotAuthorizedException;
20	import jakarta.ws.rs.NotFoundException;
21	import jakarta.ws.rs.ServerErrorException;
22	import jakarta.ws.rs.core.MediaType;
23	import java.io.IOException;
24	import java.net.URI;
25	import java.nio.charset.Charset;
26	import java.util.concurrent.Executors;
27	import java.util.concurrent.ScheduledExecutorService;
28	import java.util.concurrent.TimeUnit;
29	import org.apache.commons.io.IOUtils;
30	import org.apache.hc.client5.http.classic.HttpClient;
31	import org.apache.hc.client5.http.classic.methods.HttpGet;
32	import org.apache.hc.client5.http.impl.classic.HttpClients;
33	import org.broadinstitute.consent.http.configurations.ServicesConfiguration;
34	import org.broadinstitute.consent.http.exceptions.ConsentConflictException;
35	import org.broadinstitute.consent.http.models.AuthUser;
36
37	public class HttpClientUtil implements ConsentLogger {
38
39	public record SimpleResponse(int code, String entity) {	1✔
40
41	}
42
43	private final ServicesConfiguration configuration;
44
45	private final LoadingCache<URI, SimpleResponse> cache;
46
47	private final HttpClient httpClient;
48
49	public HttpClientUtil(ServicesConfiguration configuration) {	1✔
50	this.configuration = configuration;	1✔
51	httpClient = HttpClients.createDefault();	1✔
52	CacheLoader<URI, SimpleResponse> loader = new CacheLoader<>() {	1✔
53	@Override
54	public SimpleResponse load(URI uri) throws Exception {
55	return getHttpResponse(new HttpGet(uri));	1✔
56	}
57	};
58	this.cache = CacheBuilder	1✔
59	.newBuilder()	1✔
60	.expireAfterWrite(configuration.getCacheExpireMinutes(), TimeUnit.MINUTES)	1✔
61	.build(loader);	1✔
62	}	1✔
63
64	/**
65	* This returns the result of previously executed GET requests from a cache or executes them if
66	* they are not yet cached.
67	*
68	* @param request The HttpGet request
69	* @return SimpleResponse
70	* @throws IOException The exception
71	*/
72	public SimpleResponse getCachedResponse(HttpGet request) throws IOException {
73	try {
74	return cache.get(request.getUri());	1✔
75	} catch (Exception e) {	×
76	// Something went wrong with the cached version, log for followup
77	logWarn(e.getMessage());	×
78	return getHttpResponse(request);	×
79	}
80	}
81
82	/**
83	* This handles GET requests that could be subject to connection timeout errors by limiting the
84	* request to a configured default number of seconds.
85	*
86	* @param request The HttpGet request
87	* @return SimpleResponse
88	* @throws IOException The exception
89	*/
90	public SimpleResponse getHttpResponse(HttpGet request) throws IOException {
91	final ScheduledExecutorService executor = Executors.newScheduledThreadPool(	1✔
92	configuration.getPoolSize());	1✔
93	executor.schedule(request::cancel, configuration.getTimeoutSeconds(), TimeUnit.SECONDS);	1✔
94	return httpClient.execute(request, httpResponse ->	1✔
95	new SimpleResponse(	1✔
96	httpResponse.getCode(),	1✔
97	IOUtils.toString(httpResponse.getEntity().getContent(), Charset.defaultCharset()))	1✔
98	);
99	}
100
101	public HttpRequest buildGetRequest(GenericUrl genericUrl, AuthUser authUser) throws Exception {
102	HttpTransport transport = new NetHttpTransport();	1✔
103	HttpRequest request = transport.createRequestFactory().buildGetRequest(genericUrl);	1✔
104	request.setHeaders(buildHeaders(authUser));	1✔
105	return request;	1✔
106	}
107
108	public HttpRequest buildUnAuthedGetRequest(GenericUrl genericUrl) throws Exception {
109	HttpTransport transport = new NetHttpTransport();	1✔
110	HttpRequest request = transport.createRequestFactory().buildGetRequest(genericUrl);	1✔
111	request.setHeaders(new HttpHeaders().set("X-App-ID", "DUOS"));	1✔
112	return request;	1✔
113	}
114
115	public HttpRequest buildPostRequest(GenericUrl genericUrl, HttpContent content, AuthUser authUser)
116	throws Exception {
117	HttpTransport transport = new NetHttpTransport();	1✔
118	HttpRequest request = transport.createRequestFactory().buildPostRequest(genericUrl, content);	1✔
119	request.setHeaders(buildHeaders(authUser));	1✔
120	return request;	1✔
121	}
122
123	public HttpRequest buildPutRequest(GenericUrl genericUrl, HttpContent content, AuthUser authUser)
124	throws Exception {
125	HttpTransport transport = new NetHttpTransport();	1✔
126	HttpRequest request = transport.createRequestFactory().buildPutRequest(genericUrl, content);	1✔
127	request.setHeaders(buildHeaders(authUser));	1✔
128	return request;	1✔
129	}
130
131	public HttpRequest buildUnAuthedPostRequest(GenericUrl genericUrl, HttpContent content)
132	throws Exception {
133	HttpTransport transport = new NetHttpTransport();	1✔
134	HttpRequest request = transport.createRequestFactory().buildPostRequest(genericUrl, content);	1✔
135	request.setHeaders(new HttpHeaders().set("X-App-ID", "DUOS"));	1✔
136	return request;	1✔
137	}
138
139	public HttpResponse handleHttpRequest(HttpRequest request) {
140	String timerName = String.format("org.broadinstitute.consent.http.util.HttpClientUtil-%s-%s",	1✔
141	request.getRequestMethod(), request.getUrl().toString());	1✔
142	if (SharedMetricRegistries.tryGetDefault() == null) {	1✔
143	logWarn("Default SharedMetricRegistries is null, setting default");	×
144	SharedMetricRegistries.setDefault("org.broadinstitute.consent", new MetricRegistry());	×
145	}
146	Timer timer = SharedMetricRegistries.getDefault().timer(timerName);	1✔
147	try {
148	request.setThrowExceptionOnExecuteError(false);	1✔
149	HttpResponse response;
150	try (Timer.Context context = timer.time()) {	1✔
151	response = request.execute();	1✔
152	context.stop();	1✔
153	}
154	if (response != null) {	1✔
155	return switch (response.getStatusCode()) {	1✔
156	case HttpStatusCodes.STATUS_CODE_BAD_REQUEST ->
157	throw new BadRequestException(response.getStatusMessage());	1✔
158	case HttpStatusCodes.STATUS_CODE_UNAUTHORIZED ->
159	throw new NotAuthorizedException(response.getStatusMessage());	1✔
160	case HttpStatusCodes.STATUS_CODE_FORBIDDEN ->
161	throw new ForbiddenException(response.getStatusMessage());	1✔
162	case HttpStatusCodes.STATUS_CODE_NOT_FOUND ->
163	throw new NotFoundException(response.getStatusMessage());	1✔
164	case HttpStatusCodes.STATUS_CODE_CONFLICT ->
165	throw new ConsentConflictException(response.getStatusMessage());	1✔
166	default -> response;	1✔
167	};
168	}
169	} catch (IOException e) {	1✔
170	throw new ServerErrorException("Server Error (" + e.getMessage() + ")", HttpStatusCodes.STATUS_CODE_SERVER_ERROR);	1✔
171	}	×
172	throw new ServerErrorException("Server Error", HttpStatusCodes.STATUS_CODE_SERVER_ERROR);	×
173	}
174
175	private HttpHeaders buildHeaders(AuthUser authUser) {
176	return new HttpHeaders()	1✔
177	.setAuthorization("Bearer " + authUser.getAuthToken())	1✔
178	.setAccept(MediaType.APPLICATION_JSON)	1✔
179	.set("X-App-ID", "DUOS");	1✔
180	}
181	}

DataBiosphere / consent / #5242

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous