wfenginemgrservice/src/main/java/org/onap/workflow/common/RestClient.java

   1 /**
   2  * Copyright 2017 ZTE Corporation.
   3  *
   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  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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 package org.onap.workflow.common;
  17
  18 import java.io.IOException;
  19
  20 import org.apache.http.HttpEntity;
  21 import org.apache.http.HttpHost;
  22 import org.apache.http.HttpRequest;
  23 import org.apache.http.HttpResponse;
  24 import org.apache.http.client.ClientProtocolException;
  25 import org.apache.http.client.ResponseHandler;
  26 import org.apache.http.client.methods.CloseableHttpResponse;
  27 import org.apache.http.client.methods.HttpDelete;
  28 import org.apache.http.client.methods.HttpGet;
  29 import org.apache.http.client.methods.HttpPost;
  30 import org.apache.http.client.methods.HttpPut;
  31 import org.apache.http.entity.StringEntity;
  32 import org.apache.http.impl.client.BasicResponseHandler;
  33 import org.apache.http.impl.client.CloseableHttpClient;
  34 import org.apache.http.impl.client.HttpClients;
  35 import org.apache.http.util.EntityUtils;
  36 import org.onap.workflow.externalservice.entity.activitientitiy.ActivitiStartProcessRequest;
  37 import org.onap.workflow.tools.Constants;
  38 import org.onap.workflow.tools.HttpDeleteWithBody;
  39 import org.onap.workflow.tools.RequestParameters;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import com.google.gson.Gson;
  44
  45 public class RestClient {
  46   private static final String HTTP = "http";
  47   private static final Logger logger = LoggerFactory.getLogger(RestClient.class);
  48
  49   enum HttpMethod {
  50     GET, POST, PUT, DELETE
  51   }
  52
  53   /**
  54    *
  55    * @param method
  56    * @param ip
  57    * @param port
  58    * @param url
  59    * @param body
  60    * @return
  61    * @throws ClientProtocolException
  62    * @throws IOException
  63    */
  64   public static RestResponse executeHttp(HttpMethod method, String ip, Integer port, String url,
  65       HttpEntity body) throws ClientProtocolException, IOException {
  66     logger.info("deployfile method send");
  67     CloseableHttpClient httpclient = HttpClients.createDefault();
  68     HttpResponse httpResponse = null;
  69     RestResponse result = new RestResponse();
  70     try {
  71       if (ip == null) {
  72         ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
  73       }
  74       if (port == null) {
  75         port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
  76       }
  77       HttpHost target = new HttpHost(ip, port, HTTP);
  78       HttpRequest request = getRequest(method, url, body);
  79       logger.info("deployfile method send ip"+ip);
  80       request.addHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());
  81
  82       httpResponse = httpclient.execute(target, request);
  83       HttpEntity entity = httpResponse.getEntity();
  84       logger.info("deployfile method send");
  85       if (entity != null) {
  86         result.setStatusCode(httpResponse.getStatusLine().getStatusCode());
  87         logger.info("reply status code deploy"+httpResponse.getStatusLine().getStatusCode());
  88         result.setResult(EntityUtils.toString(entity));
  89       }
  90     } catch (IOException e) {
  91       logger.warn("Close httpclient failed.", e);
  92     } finally {
  93       if (httpclient != null) {
  94         try {
  95           httpclient.close();
  96         } catch (IOException e) {
  97           logger.warn("Close httpclient failed.", e);
  98         }
  99       }
 100     }
 101     return result;
 102   }
 103
 104   private static HttpRequest getRequest(HttpMethod method, String url, HttpEntity body) {
 105     HttpRequest request = null;
 106     switch (method) {
 107       case GET:
 108         request = new HttpGet(url);
 109         break;
 110       case POST:
 111         request = new HttpPost(url);
 112         ((HttpPost) request).setEntity(body);
 113         break;
 114       case PUT:
 115         request = new HttpPut(url);
 116         ((HttpPut) request).setEntity(body);
 117         break;
 118       case DELETE:
 119         request = new HttpDelete(url);
 120         break;
 121       default:
 122         break;
 123     }
 124     return request;
 125   }
 126
 127   /**
 128    *
 129    * @param ip
 130    * @param port
 131    * @param url
 132    * @return
 133    * @throws ClientProtocolException
 134    * @throws IOException
 135    */
 136   public static String get(String ip, int port, String url)
 137       throws ClientProtocolException, IOException {
 138     return executeHttp(HttpMethod.GET, ip, port, url, null).getResult();
 139   }
 140
 141   /**
 142    *
 143    * @param ip
 144    * @param port
 145    * @param url
 146    * @return
 147    * @throws ClientProtocolException
 148    * @throws IOException
 149    */
 150   public static RestResponse delete(String ip, int port, String url)
 151       throws ClientProtocolException, IOException {
 152     return executeHttp(HttpMethod.GET, ip, port, url, null);
 153   }
 154
 155   /**
 156    *
 157    * @param ip
 158    * @param port
 159    * @param url
 160    * @param requestBody
 161    * @return
 162    * @throws ClientProtocolException
 163    * @throws IOException
 164    */
 165   public static RestResponse post(String ip, int port, String url, HttpEntity requestBody)
 166       throws ClientProtocolException, IOException {
 167     return executeHttp(HttpMethod.POST, ip, port, url, requestBody);
 168   }
 169
 170
 171
 172   /**
 173    *
 174    * @param method
 175    * @param ip
 176    * @param port
 177    * @param url
 178    * @param body
 179    * @return
 180    * @throws ClientProtocolException
 181    * @throws IOException
 182    */
 183   public static RestResponse executeHttpDeleteDeploy(HttpMethod method, String ip, Integer port,
 184       String url) throws ClientProtocolException, IOException {
 185     if (ip == null) {
 186       ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
 187     }
 188     port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
 189     RestResponse result = new RestResponse();
 190     CloseableHttpClient httpClient = HttpClients.createDefault();
 191     try {
 192       httpClient = HttpClients.createDefault();
 193       // "http://localhost:8080/activiti-rest/service/repository/deployments/167501"
 194       String deleteUrl = Constants.HTTP_HEADER + ip + Constants.COLON + port + url;
 195       HttpDeleteWithBody httpDeteTest = new HttpDeleteWithBody(deleteUrl);
 196       Gson gson = new Gson();
 197       RequestParameters reqPa = new RequestParameters();
 198       reqPa.setCasCade(true);
 199       String jsonStr = gson.toJson(reqPa, RequestParameters.class);
 200       StringEntity requestEntity = new StringEntity(jsonStr, "UTF-8");
 201       requestEntity.setContentEncoding("UTF-8");
 202       httpDeteTest.setHeader("Content-type", "application/json");
 203       httpDeteTest.setHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());
 204       httpDeteTest.setEntity(new StringEntity(jsonStr));
 205       // returnValue = httpClient.execute(httpDeteTest, responseHandler); // 调接口获取返回值时，必须用此方法
 206       CloseableHttpResponse httpResonse = httpClient.execute(httpDeteTest);
 207       int statusCode = httpResonse.getStatusLine().getStatusCode();
 208       result.setStatusCode(statusCode);
 209    //   result.setResult(EntityUtils.toString(httpResonse.getEntity()));
 210     } catch (Exception e) {
 211       e.printStackTrace();
 212     }
 213
 214     finally {
 215       try {
 216         httpClient.close();
 217       } catch (IOException e) {
 218         // TODO Auto-generated catch block
 219         e.printStackTrace();
 220       }
 221     }
 222
 223     return result;
 224   }
 225
 226   /**
 227    *
 228    * @param method
 229    * @param ip
 230    * @param port
 231    * @param url
 232    * @param body
 233    * @return
 234    * @throws ClientProtocolException
 235    * @throws IOException
 236    */
 237   public static RestResponse executeHttpStartIntance(HttpMethod method, String ip, Integer port,
 238       String url, ActivitiStartProcessRequest object) throws ClientProtocolException, IOException {
 239     String returnValue = "";
 240     RestResponse result = new RestResponse();
 241     CloseableHttpClient httpClient = HttpClients.createDefault();
 242     ResponseHandler<String> responseHandler = new BasicResponseHandler();
 243     try {
 244       httpClient = HttpClients.createDefault();
 245       if (ip == null) {
 246         ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
 247       }
 248       port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
 249
 250       HttpPost httpPost = new HttpPost(Constants.HTTP_HEADER + ip + ":" + port + url);
 251       Gson gson = new Gson();
 252       String jsonStr = gson.toJson(object, ActivitiStartProcessRequest.class);
 253       StringEntity requestEntity = new StringEntity(jsonStr, "utf-8");
 254       requestEntity.setContentEncoding("UTF-8");
 255       httpPost.setHeader("Content-type", "application/json");
 256       httpPost.setHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());
 257       httpPost.setEntity(requestEntity);
 258       returnValue = httpClient.execute(httpPost, responseHandler); // 调接口获取返回值时，必须用此方法
 259       CloseableHttpResponse httpResonse = httpClient.execute(httpPost);
 260       int statusCode = httpResonse.getStatusLine().getStatusCode();
 261       returnValue = EntityUtils.toString(httpResonse.getEntity(),"UTF-8");
 262       result.setStatusCode(statusCode);
 263       result.setResult(returnValue);
 264     } catch (Exception e) {
 265       e.printStackTrace();
 266     }
 267
 268     finally {
 269       try {
 270         httpClient.close();
 271       } catch (IOException e) {
 272         // TODO Auto-generated catch block
 273         e.printStackTrace();
 274       }
 275     }
 276
 277     return result;
 278   }
 279
 280   /**
 281    *
 282    * @param ip
 283    * @param port
 284    * @param url
 285    * @param requestBody
 286    * @return
 287    * @throws ClientProtocolException
 288    * @throws IOException
 289    */
 290   public static RestResponse post(String ip, Integer port, String url,
 291       ActivitiStartProcessRequest requestBody) throws ClientProtocolException, IOException {
 292     return executeHttpStartIntance(HttpMethod.POST, ip, port, url, requestBody);
 293   }
 294
 295   /**
 296    *
 297    * @param ip
 298    * @param port
 299    * @param url
 300    * @param requestBody
 301    * @return
 302    * @throws ClientProtocolException
 303    * @throws IOException
 304    */
 305   public static RestResponse post(String ip, Integer port, String url)
 306       throws ClientProtocolException, IOException {
 307     return executeHttpDeleteDeploy(HttpMethod.DELETE, ip, port, url);
 308   }
 309
 310 }