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.eclipse.jetty.http.HttpStatus;
  20 import org.onap.holmes.common.exception.HttpException;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  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;
  32 import java.util.*;
  33 import java.util.concurrent.TimeUnit;
  34
  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;
  41
  42     static {
  43         try {
  44             SSLCONTEXT = SSLContext.getInstance("TLS");
  45             SSLCONTEXT.init(null, new TrustManager[]{new X509TrustManager() {
  46                 public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
  47                 }
  48
  49                 public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
  50                 }
  51
  52                 public X509Certificate[] getAcceptedIssuers() {
  53                     return new X509Certificate[0];
  54                 }
  55             }}, new java.security.SecureRandom());
  56         } catch (NoSuchAlgorithmException | KeyManagementException e) {
  57             logger.error("Failed to initialize the SSLContext instance!", e);
  58         }
  59     }
  60
  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();
  65
  66
  67     public JerseyClient() {
  68         this(DEFAULT_TIMEOUT);
  69     }
  70
  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)
  77                 .build();
  78     }
  79
  80     public JerseyClient header(String name, Object value) {
  81         headers.put(name, value);
  82         return this;
  83     }
  84
  85     public JerseyClient headers(Map<String, Object> hds) {
  86         headers.putAll(hds);
  87         return this;
  88     }
  89
  90     public JerseyClient queryParam(String name, Object value) {
  91         parameters.put(name, value);
  92         return this;
  93     }
  94
  95     public JerseyClient queryParams(Map<String, Object> params) {
  96         parameters.putAll(params);
  97         return this;
  98     }
  99
 100     public JerseyClient path(String path) {
 101         paths.add(path);
 102         return this;
 103     }
 104
 105     public String get(String url) {
 106         return get(url, String.class);
 107     }
 108
 109     public <T> T get(String url, Class<T> clazz) {
 110
 111         WebTarget target = appendPaths(client.target(url));
 112
 113         target = setParameters(target);
 114
 115         Invocation.Builder builder = setHeaders(target.request());
 116
 117         Response response = builder.get();
 118
 119         if (isSuccessful(response)) {
 120             return response2Target(response, clazz);
 121         }
 122
 123         return null;
 124     }
 125
 126     public String post(String url) {
 127         return post(url, null);
 128     }
 129
 130     public String post(String url, Entity entity) {
 131         return post(url, entity, String.class);
 132     }
 133
 134     public <T> T post(String url, Entity entity, Class<T> clazz) {
 135
 136         WebTarget target = appendPaths(client.target(url));
 137
 138         setParameters(target);
 139
 140         Invocation.Builder builder = setHeaders(target.request());
 141
 142         Response response = builder.post(entity);
 143
 144         if (isSuccessful(response)) {
 145             return response2Target(response, clazz);
 146         }
 147
 148         return null;
 149     }
 150
 151     public String put(String url, Entity entity) {
 152         return put(url, entity, String.class);
 153     }
 154
 155     public <T> T put(String url, Entity entity, Class<T> clazz) {
 156         WebTarget target = appendPaths(client.target(url));
 157
 158         setParameters(target);
 159
 160         Invocation.Builder builder = setHeaders(target.request());
 161
 162         Response response = builder.put(entity);
 163
 164         if (isSuccessful(response)) {
 165             return response2Target(response, clazz);
 166         }
 167
 168         return null;
 169     }
 170
 171     public String delete(String url) {
 172         return delete(url, String.class);
 173     }
 174
 175     public <T> T delete(String url, Class<T> clazz) {
 176         WebTarget target = appendPaths(client.target(url));
 177
 178         setParameters(target);
 179
 180         Invocation.Builder builder = setHeaders(target.request());
 181
 182         Response response = builder.delete();
 183
 184         if (isSuccessful(response)) {
 185             return response2Target(response, clazz);
 186         }
 187
 188         return null;
 189     }
 190
 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)));
 196         }
 197         return true;
 198     }
 199
 200     private WebTarget appendPaths(WebTarget target) {
 201         for (String path : paths) {
 202             target = target.path(path);
 203         }
 204         return target;
 205     }
 206
 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());
 211         }
 212         return builder;
 213     }
 214
 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());
 219         }
 220         return target;
 221     }
 222
 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;
 227         } else {
 228             return GsonUtil.jsonToBean(responseText, clazz);
 229         }
 230     }
 231 }