/**
* Copyright 2020 ZTE Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onap.holmes.common.utils;
import org.eclipse.jetty.http.HttpStatus;
import org.onap.holmes.common.exception.HttpException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.ws.rs.client.*;
import javax.ws.rs.core.Response;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.*;
import java.util.concurrent.TimeUnit;
public class JerseyClient {
static final public String PROTOCOL_HTTP = "http";
static final public String PROTOCOL_HTTPS = "https";
static private Logger logger = LoggerFactory.getLogger(JerseyClient.class);
static private long DEFAULT_TIMEOUT = TimeUnit.SECONDS.toMillis(30);
static private SSLContext SSLCONTEXT;
static {
try {
SSLCONTEXT = SSLContext.getInstance("TLS");
SSLCONTEXT.init(null, new TrustManager[]{new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
}
public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
}
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
}}, new java.security.SecureRandom());
} catch (NoSuchAlgorithmException | KeyManagementException e) {
logger.error("Failed to initialize the SSLContext instance!", e);
}
}
private Client client;
private Map headers = new HashMap();
private Map parameters = new HashMap();
private List paths = new ArrayList();
public JerseyClient() {
this(DEFAULT_TIMEOUT);
}
public JerseyClient(long timeout) {
this.client = ClientBuilder.newBuilder()
.connectTimeout(timeout, TimeUnit.MILLISECONDS)
.readTimeout(timeout, TimeUnit.MILLISECONDS)
.sslContext(SSLCONTEXT)
.hostnameVerifier((s1, s2) -> true)
.build();
}
public JerseyClient header(String name, Object value) {
headers.put(name, value);
return this;
}
public JerseyClient headers(Map hds) {
headers.putAll(hds);
return this;
}
public JerseyClient queryParam(String name, Object value) {
parameters.put(name, value);
return this;
}
public JerseyClient queryParams(Map params) {
parameters.putAll(params);
return this;
}
public JerseyClient path(String path) {
paths.add(path);
return this;
}
public String get(String url) {
return get(url, String.class);
}
public T get(String url, Class clazz) {
WebTarget target = appendPaths(client.target(url));
target = setParameters(target);
Invocation.Builder builder = setHeaders(target.request());
Response response = builder.get();
if (isSuccessful(response)) {
return response2Target(response, clazz);
}
return null;
}
public String post(String url) {
return post(url, null);
}
public String post(String url, Entity entity) {
return post(url, entity, String.class);
}
public T post(String url, Entity entity, Class clazz) {
WebTarget target = appendPaths(client.target(url));
setParameters(target);
Invocation.Builder builder = setHeaders(target.request());
Response response = builder.post(entity);
if (isSuccessful(response)) {
return response2Target(response, clazz);
}
return null;
}
public String put(String url, Entity entity) {
return put(url, entity, String.class);
}
public T put(String url, Entity entity, Class clazz) {
WebTarget target = appendPaths(client.target(url));
setParameters(target);
Invocation.Builder builder = setHeaders(target.request());
Response response = builder.put(entity);
if (isSuccessful(response)) {
return response2Target(response, clazz);
}
return null;
}
public String delete(String url) {
return delete(url, String.class);
}
public T delete(String url, Class clazz) {
WebTarget target = appendPaths(client.target(url));
setParameters(target);
Invocation.Builder builder = setHeaders(target.request());
Response response = builder.delete();
if (isSuccessful(response)) {
return response2Target(response, clazz);
}
return null;
}
private boolean isSuccessful(Response response) {
int status = response.getStatus();
if (!HttpStatus.isSuccess(status)) {
throw new HttpException(status, String.format("Failed to get response from the server. Info: %s",
response.readEntity(String.class)));
}
return true;
}
private WebTarget appendPaths(WebTarget target) {
for (String path : paths) {
target = target.path(path);
}
return target;
}
private Invocation.Builder setHeaders(Invocation.Builder builder) {
Set> entries = headers.entrySet();
for (Map.Entry entry : entries) {
builder = builder.header(entry.getKey(), entry.getValue());
}
return builder;
}
private WebTarget setParameters(WebTarget target) {
Set> entries = parameters.entrySet();
for (Map.Entry entry : entries) {
target = target.queryParam(entry.getKey(), entry.getValue());
}
return target;
}
private T response2Target(Response response, Class clazz) {
String responseText = response.readEntity(String.class);
if (clazz == null || clazz == String.class) {
return (T) responseText;
} else {
return GsonUtil.jsonToBean(responseText, clazz);
}
}
}