holmes-actions/src/main/java/org/onap/holmes/common/utils/JerseyClient.java

   1 /**
   2  * Copyright 2020 ZTE Corporation.
   3  * <p>
   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
   7  * <p>
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  * <p>
  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.
  15  */
  16
  17 package org.onap.holmes.common.utils;
  18
  19 import org.onap.holmes.common.exception.HttpException;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 import javax.net.ssl.SSLContext;
  24 import javax.net.ssl.TrustManager;
  25 import javax.net.ssl.X509TrustManager;
  26 import javax.ws.rs.client.*;
  27 import javax.ws.rs.core.Response;
  28 import java.security.KeyManagementException;
  29 import java.security.NoSuchAlgorithmException;
  30 import java.security.cert.X509Certificate;
  31 import java.util.*;
  32 import java.util.concurrent.TimeUnit;
  33
  34 public class JerseyClient {
  35     static final public String PROTOCOL_HTTP = "http";
  36     static final public String PROTOCOL_HTTPS = "https";
  37     static private Logger logger = LoggerFactory.getLogger(JerseyClient.class);
  38     static private long DEFAULT_TIMEOUT = TimeUnit.SECONDS.toMillis(30);
  39     static private SSLContext SSLCONTEXT;
  40
  41     static {
  42         try {
  43             SSLCONTEXT = SSLContext.getInstance("TLS");
  44             SSLCONTEXT.init(null, new TrustManager[]{new X509TrustManager() {
  45                 public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
  46                 }
  47
  48                 public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
  49                 }
  50
  51                 public X509Certificate[] getAcceptedIssuers() {
  52                     return new X509Certificate[0];
  53                 }
  54             }}, new java.security.SecureRandom());
  55         } catch (NoSuchAlgorithmException | KeyManagementException e) {
  56             logger.error("Failed to initialize the SSLContext instance!", e);
  57         }
  58     }
  59
  60     private Client client;
  61     private Map<String, Object> headers = new HashMap();
  62     private Map<String, Object> parameters = new HashMap();
  63     private List<String> paths = new ArrayList();
  64
  65     public static JerseyClient newInstance() {
  66         return new JerseyClient();
  67     }
  68
  69     public static JerseyClient newInstance(long timeout) {
  70         return new JerseyClient(timeout);
  71     }
  72
  73     private JerseyClient() {
  74         this(DEFAULT_TIMEOUT);
  75     }
  76
  77     private JerseyClient(long timeout) {
  78         this.client = ClientBuilder.newBuilder()
  79                 .connectTimeout(timeout, TimeUnit.MILLISECONDS)
  80                 .readTimeout(timeout, TimeUnit.MILLISECONDS)
  81                 .sslContext(SSLCONTEXT)
  82                 .hostnameVerifier((s1, s2) -> true)
  83                 .build();
  84     }
  85
  86     public JerseyClient header(String name, Object value) {
  87         headers.put(name, value);
  88         return this;
  89     }
  90
  91     public JerseyClient headers(Map<String, Object> hds) {
  92         headers.putAll(hds);
  93         return this;
  94     }
  95
  96     public JerseyClient queryParam(String name, Object value) {
  97         parameters.put(name, value);
  98         return this;
  99     }
 100
 101     public JerseyClient queryParams(Map<String, Object> params) {
 102         parameters.putAll(params);
 103         return this;
 104     }
 105
 106     public JerseyClient path(String path) {
 107         paths.add(path);
 108         return this;
 109     }
 110
 111     public String get(String url) {
 112         return get(url, String.class);
 113     }
 114
 115     public <T> T get(String url, Class<T> clazz) {
 116
 117         WebTarget target = appendPaths(client.target(url));
 118
 119         target = setParameters(target);
 120
 121         Invocation.Builder builder = setHeaders(target.request());
 122
 123         Response response = builder.get();
 124
 125         if (isSuccessful(response, url)) {
 126             return response2Target(response, clazz);
 127         }
 128
 129         return null;
 130     }
 131
 132     public String post(String url) {
 133         return post(url, null);
 134     }
 135
 136     public String post(String url, Entity entity) {
 137         return post(url, entity, String.class);
 138     }
 139
 140     public <T> T post(String url, Entity entity, Class<T> clazz) {
 141
 142         WebTarget target = appendPaths(client.target(url));
 143
 144         setParameters(target);
 145
 146         Invocation.Builder builder = setHeaders(target.request());
 147
 148         Response response = builder.post(entity);
 149
 150         if (isSuccessful(response, url)) {
 151             return response2Target(response, clazz);
 152         }
 153
 154         return null;
 155     }
 156
 157     public String put(String url, Entity entity) {
 158         return put(url, entity, String.class);
 159     }
 160
 161     public <T> T put(String url, Entity entity, Class<T> clazz) {
 162         WebTarget target = appendPaths(client.target(url));
 163
 164         setParameters(target);
 165
 166         Invocation.Builder builder = setHeaders(target.request());
 167
 168         Response response = builder.put(entity);
 169
 170         if (isSuccessful(response, url)) {
 171             return response2Target(response, clazz);
 172         }
 173
 174         return null;
 175     }
 176
 177     public String delete(String url) {
 178         return delete(url, String.class);
 179     }
 180
 181     public <T> T delete(String url, Class<T> clazz) {
 182         WebTarget target = appendPaths(client.target(url));
 183
 184         setParameters(target);
 185
 186         Invocation.Builder builder = setHeaders(target.request());
 187
 188         Response response = builder.delete();
 189
 190         if (isSuccessful(response, url)) {
 191             return response2Target(response, clazz);
 192         }
 193
 194         return null;
 195     }
 196
 197     private boolean isSuccessful(Response response, String url) {
 198         Response.StatusType statusInfo = response.getStatusInfo();
 199         if (statusInfo.getFamily() != Response.Status.Family.SUCCESSFUL) {
 200             logger.error(
 201                     String.format("Failed to get response from the server <%d>. " +
 202                                     "\nURL: %s\nCause: %s\nResponse body: %s",
 203                             statusInfo.getStatusCode(),
 204                             url,
 205                             statusInfo.getReasonPhrase(),
 206                             response.readEntity(String.class)));
 207             return false;
 208         }
 209         return true;
 210     }
 211
 212     private WebTarget appendPaths(WebTarget target) {
 213         for (String path : paths) {
 214             target = target.path(path);
 215         }
 216         return target;
 217     }
 218
 219     private Invocation.Builder setHeaders(Invocation.Builder builder) {
 220         Set<Map.Entry<String, Object>> entries = headers.entrySet();
 221         for (Map.Entry<String, Object> entry : entries) {
 222             builder = builder.header(entry.getKey(), entry.getValue());
 223         }
 224         return builder;
 225     }
 226
 227     private WebTarget setParameters(WebTarget target) {
 228         Set<Map.Entry<String, Object>> entries = parameters.entrySet();
 229         for (Map.Entry<String, Object> entry : entries) {
 230             target = target.queryParam(entry.getKey(), entry.getValue());
 231         }
 232         return target;
 233     }
 234
 235     private <T> T response2Target(Response response, Class<T> clazz) {
 236         String responseText = response.readEntity(String.class);
 237         if (clazz == null || clazz == String.class) {
 238             return (T) responseText;
 239         } else {
 240             return GsonUtil.jsonToBean(responseText, clazz);
 241         }
 242     }
 243 }