2 * Copyright 2020 ZTE Corporation.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.onap.holmes.common.utils;
19 import org.eclipse.jetty.http.HttpStatus;
20 import org.onap.holmes.common.exception.HttpException;
21 import org.slf4j.Logger;
22 import org.slf4j.LoggerFactory;
24 import javax.net.ssl.SSLContext;
25 import javax.net.ssl.TrustManager;
26 import javax.net.ssl.X509TrustManager;
27 import javax.ws.rs.client.*;
28 import javax.ws.rs.core.Response;
29 import java.security.KeyManagementException;
30 import java.security.NoSuchAlgorithmException;
31 import java.security.cert.X509Certificate;
33 import java.util.concurrent.TimeUnit;
35 public class JerseyClient {
36 static final public String PROTOCOL_HTTP = "http";
37 static final public String PROTOCOL_HTTPS = "https";
38 static private Logger logger = LoggerFactory.getLogger(JerseyClient.class);
39 static private long DEFAULT_TIMEOUT = TimeUnit.SECONDS.toMillis(30);
40 static private SSLContext SSLCONTEXT;
44 SSLCONTEXT = SSLContext.getInstance("TLS");
45 SSLCONTEXT.init(null, new TrustManager[]{new X509TrustManager() {
46 public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
49 public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
52 public X509Certificate[] getAcceptedIssuers() {
53 return new X509Certificate[0];
55 }}, new java.security.SecureRandom());
56 } catch (NoSuchAlgorithmException | KeyManagementException e) {
57 logger.error("Failed to initialize the SSLContext instance!", e);
61 private Client client;
62 private Map<String, Object> headers = new HashMap();
63 private Map<String, Object> parameters = new HashMap();
64 private List<String> paths = new ArrayList();
67 public JerseyClient() {
68 this(DEFAULT_TIMEOUT);
71 public JerseyClient(long timeout) {
72 this.client = ClientBuilder.newBuilder()
73 .connectTimeout(timeout, TimeUnit.MILLISECONDS)
74 .readTimeout(timeout, TimeUnit.MILLISECONDS)
75 .sslContext(SSLCONTEXT)
76 .hostnameVerifier((s1, s2) -> true)
80 public JerseyClient header(String name, Object value) {
81 headers.put(name, value);
85 public JerseyClient headers(Map<String, Object> hds) {
90 public JerseyClient queryParam(String name, Object value) {
91 parameters.put(name, value);
95 public JerseyClient queryParams(Map<String, Object> params) {
96 parameters.putAll(params);
100 public JerseyClient path(String path) {
105 public String get(String url) {
106 return get(url, String.class);
109 public <T> T get(String url, Class<T> clazz) {
111 WebTarget target = appendPaths(client.target(url));
113 target = setParameters(target);
115 Invocation.Builder builder = setHeaders(target.request());
117 Response response = builder.get();
119 if (isSuccessful(response)) {
120 return response2Target(response, clazz);
126 public String post(String url) {
127 return post(url, null);
130 public String post(String url, Entity entity) {
131 return post(url, entity, String.class);
134 public <T> T post(String url, Entity entity, Class<T> clazz) {
136 WebTarget target = appendPaths(client.target(url));
138 setParameters(target);
140 Invocation.Builder builder = setHeaders(target.request());
142 Response response = builder.post(entity);
144 if (isSuccessful(response)) {
145 return response2Target(response, clazz);
151 public String put(String url, Entity entity) {
152 return put(url, entity, String.class);
155 public <T> T put(String url, Entity entity, Class<T> clazz) {
156 WebTarget target = appendPaths(client.target(url));
158 setParameters(target);
160 Invocation.Builder builder = setHeaders(target.request());
162 Response response = builder.put(entity);
164 if (isSuccessful(response)) {
165 return response2Target(response, clazz);
171 public String delete(String url) {
172 return delete(url, String.class);
175 public <T> T delete(String url, Class<T> clazz) {
176 WebTarget target = appendPaths(client.target(url));
178 setParameters(target);
180 Invocation.Builder builder = setHeaders(target.request());
182 Response response = builder.delete();
184 if (isSuccessful(response)) {
185 return response2Target(response, clazz);
191 private boolean isSuccessful(Response response) {
192 int status = response.getStatus();
193 if (!HttpStatus.isSuccess(status)) {
194 throw new HttpException(status, String.format("Failed to get response from the server. Info: %s",
195 response.readEntity(String.class)));
200 private WebTarget appendPaths(WebTarget target) {
201 for (String path : paths) {
202 target = target.path(path);
207 private Invocation.Builder setHeaders(Invocation.Builder builder) {
208 Set<Map.Entry<String, Object>> entries = headers.entrySet();
209 for (Map.Entry<String, Object> entry : entries) {
210 builder = builder.header(entry.getKey(), entry.getValue());
215 private WebTarget setParameters(WebTarget target) {
216 Set<Map.Entry<String, Object>> entries = parameters.entrySet();
217 for (Map.Entry<String, Object> entry : entries) {
218 target = target.queryParam(entry.getKey(), entry.getValue());
223 private <T> T response2Target(Response response, Class<T> clazz) {
224 String responseText = response.readEntity(String.class);
225 if (clazz == null || clazz == String.class) {
226 return (T) responseText;
228 return GsonUtil.jsonToBean(responseText, clazz);