2 * Copyright 2020 - 2022 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 jakarta.ws.rs.client.*;
20 import jakarta.ws.rs.core.Response;
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 java.security.KeyManagementException;
28 import java.security.NoSuchAlgorithmException;
29 import java.security.cert.X509Certificate;
31 import java.util.concurrent.TimeUnit;
33 public class JerseyClient {
34 static final public String PROTOCOL_HTTP = "http";
35 static final public String PROTOCOL_HTTPS = "https";
36 static private Logger logger = LoggerFactory.getLogger(JerseyClient.class);
37 static private long DEFAULT_TIMEOUT = TimeUnit.SECONDS.toMillis(30);
38 static private SSLContext SSLCONTEXT;
42 SSLCONTEXT = SSLContext.getInstance("TLS");
43 SSLCONTEXT.init(null, new TrustManager[]{new X509TrustManager() {
44 public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
47 public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
50 public X509Certificate[] getAcceptedIssuers() {
51 return new X509Certificate[0];
53 }}, new java.security.SecureRandom());
54 } catch (NoSuchAlgorithmException | KeyManagementException e) {
55 logger.error("Failed to initialize the SSLContext instance!", e);
59 private Client client;
60 private Map<String, Object> headers = new HashMap();
61 private Map<String, Object> parameters = new HashMap();
62 private List<String> paths = new ArrayList();
64 public static JerseyClient newInstance() {
65 return new JerseyClient();
68 public static JerseyClient newInstance(long timeout) {
69 return new JerseyClient(timeout);
72 private JerseyClient() {
73 this(DEFAULT_TIMEOUT);
76 private JerseyClient(long timeout) {
77 this.client = ClientBuilder.newBuilder()
78 .connectTimeout(timeout, TimeUnit.MILLISECONDS)
79 .readTimeout(timeout, TimeUnit.MILLISECONDS)
80 .sslContext(SSLCONTEXT)
81 .hostnameVerifier((s1, s2) -> true)
85 public JerseyClient header(String name, Object value) {
86 headers.put(name, value);
90 public JerseyClient headers(Map<String, Object> hds) {
95 public JerseyClient queryParam(String name, Object value) {
96 parameters.put(name, value);
100 public JerseyClient queryParams(Map<String, Object> params) {
101 parameters.putAll(params);
105 public JerseyClient path(String path) {
110 public String get(String url) {
111 return get(url, String.class);
114 public <T> T get(String url, Class<T> clazz) {
116 WebTarget target = appendPaths(client.target(url));
118 target = setParameters(target);
120 Invocation.Builder builder = setHeaders(target.request());
122 Response response = builder.get();
124 if (isSuccessful(response, url)) {
125 return response2Target(response, clazz);
131 public String post(String url) {
132 return post(url, null);
135 public String post(String url, Entity entity) {
136 return post(url, entity, String.class);
139 public <T> T post(String url, Entity entity, Class<T> clazz) {
141 WebTarget target = appendPaths(client.target(url));
143 setParameters(target);
145 Invocation.Builder builder = setHeaders(target.request());
147 Response response = builder.post(entity);
149 if (isSuccessful(response, url)) {
150 return response2Target(response, clazz);
156 public String put(String url, Entity entity) {
157 return put(url, entity, String.class);
160 public <T> T put(String url, Entity entity, Class<T> clazz) {
161 WebTarget target = appendPaths(client.target(url));
163 setParameters(target);
165 Invocation.Builder builder = setHeaders(target.request());
167 Response response = builder.put(entity);
169 if (isSuccessful(response, url)) {
170 return response2Target(response, clazz);
176 public String delete(String url) {
177 return delete(url, String.class);
180 public <T> T delete(String url, Class<T> clazz) {
181 WebTarget target = appendPaths(client.target(url));
183 setParameters(target);
185 Invocation.Builder builder = setHeaders(target.request());
187 Response response = builder.delete();
189 if (isSuccessful(response, url)) {
190 return response2Target(response, clazz);
196 private boolean isSuccessful(Response response, String url) {
197 Response.StatusType statusInfo = response.getStatusInfo();
198 if (statusInfo.getFamily() != Response.Status.Family.SUCCESSFUL) {
200 String.format("Failed to get response from the server <%d>. " +
201 "\nURL: %s\nCause: %s\nResponse body: %s",
202 statusInfo.getStatusCode(),
204 statusInfo.getReasonPhrase(),
205 response.readEntity(String.class)));
211 private WebTarget appendPaths(WebTarget target) {
212 for (String path : paths) {
213 target = target.path(path);
218 private Invocation.Builder setHeaders(Invocation.Builder builder) {
219 Set<Map.Entry<String, Object>> entries = headers.entrySet();
220 for (Map.Entry<String, Object> entry : entries) {
221 builder = builder.header(entry.getKey(), entry.getValue());
226 private WebTarget setParameters(WebTarget target) {
227 Set<Map.Entry<String, Object>> entries = parameters.entrySet();
228 for (Map.Entry<String, Object> entry : entries) {
229 target = target.queryParam(entry.getKey(), entry.getValue());
234 private <T> T response2Target(Response response, Class<T> clazz) {
235 String responseText = response.readEntity(String.class);
236 if (clazz == null || clazz == String.class) {
237 return (T) responseText;
239 return GsonUtil.jsonToBean(responseText, clazz);