cadi/client/src/main/java/org/onap/aaf/cadi/http/HClient.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.cadi.http;
  23
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.InputStreamReader;
  27 import java.io.OutputStream;
  28 import java.io.Reader;
  29 import java.net.HttpURLConnection;
  30 import java.net.URI;
  31 import java.net.URISyntaxException;
  32 import java.net.URL;
  33 import java.util.ArrayList;
  34
  35 import javax.servlet.http.HttpServletResponse;
  36
  37 import org.onap.aaf.cadi.CadiException;
  38 import org.onap.aaf.cadi.LocatorException;
  39 import org.onap.aaf.cadi.SecuritySetter;
  40 import org.onap.aaf.cadi.client.EClient;
  41 import org.onap.aaf.cadi.client.Future;
  42 import org.onap.aaf.cadi.client.Rcli;
  43 import org.onap.aaf.misc.env.APIException;
  44 import org.onap.aaf.misc.env.Data;
  45 import org.onap.aaf.misc.env.Data.TYPE;
  46 import org.onap.aaf.misc.env.util.Pool.Pooled;
  47 import org.onap.aaf.misc.rosetta.env.RosettaDF;
  48
  49 /**
  50  * Low Level Http Client Mechanism. Chances are, you want the high level "HRcli"
  51  * for Rosetta Object Translation
  52  *
  53  * @author Jonathan
  54  *
  55  */
  56 public class HClient implements EClient<HttpURLConnection> {
  57         private URI uri;
  58         private ArrayList<Header> headers;
  59         private String meth;
  60         private String pathinfo;
  61         private String query;
  62         private String fragment;
  63         private Transfer transfer;
  64         private SecuritySetter<HttpURLConnection> ss;
  65         private HttpURLConnection huc;
  66         private int connectTimeout;
  67
  68         public HClient(SecuritySetter<HttpURLConnection> ss, URI uri,int connectTimeout) throws LocatorException {
  69                 if (uri == null) {
  70                         throw new LocatorException("No Service available to call");
  71                 }
  72                 this.uri = uri;
  73                 this.ss = ss;
  74                 this.connectTimeout = connectTimeout;
  75                 pathinfo = query = fragment = null;
  76         }
  77
  78         @Override
  79         public void setMethod(String meth) {
  80                 this.meth = meth;
  81         }
  82
  83         @Override
  84         public void setPathInfo(String pathinfo) {
  85                 this.pathinfo = pathinfo;
  86         }
  87
  88         @Override
  89         public void setPayload(Transfer transfer) {
  90                 this.transfer = transfer;
  91         }
  92
  93         @Override
  94         public void addHeader(String tag, String value) {
  95                 if (headers == null)
  96                         headers = new ArrayList<>();
  97                 headers.add(new Header(tag, value));
  98         }
  99
 100         @Override
 101         public void setQueryParams(String q) {
 102                 query = q;
 103         }
 104
 105         @Override
 106         public void setFragment(String f) {
 107                 fragment = f;
 108         }
 109
 110         @Override
 111         public void send() throws APIException {
 112                 try {
 113                         // Build URL from given URI plus current Settings
 114                         if(uri.getPath()==null) {
 115                                 throw new APIException("Invalid URL entered for HClient");
 116                         }
 117                         StringBuilder pi=null;
 118                         if(pathinfo!=null) { // additional pathinfo
 119                                 pi = new StringBuilder(uri.getPath());
 120                                 if(!pathinfo.startsWith("/")) {
 121                                         pi.append('/');
 122                                 }
 123                                 pi.append(pathinfo);
 124                         }
 125                         URI sendURI = new URI(
 126                                         uri.getScheme(),
 127                                         uri.getUserInfo(),
 128                                         uri.getHost(),
 129                                         uri.getPort(),
 130                                         pi==null?uri.getPath():pi.toString(),
 131                                         query==null?uri.getQuery():query,
 132                                         fragment==null?uri.getFragment():fragment
 133                                         );
 134                         huc = getConnection(sendURI, pi);
 135                         huc.setRequestMethod(meth);
 136                         if(ss!=null) {
 137                                 ss.setSecurity(huc);
 138                         }
 139                         if (headers != null)
 140                                 for (Header d : headers) {
 141                                         huc.addRequestProperty(d.tag, d.value);
 142                                 }
 143                         huc.setDoInput(true);
 144                         huc.setDoOutput(true);
 145                         huc.setUseCaches(false);
 146                         huc.setConnectTimeout(connectTimeout);
 147                         huc.connect();
 148                         if (transfer != null) {
 149                                 transfer.transfer(huc.getOutputStream());
 150                         }
 151                         // TODO other settings? There's a bunch here.
 152                 } catch (Exception e) {
 153                         throw new APIException(e);
 154                 } finally { // ensure all these are reset after sends
 155                         meth=pathinfo=null;
 156                         if(headers!=null) {
 157                                 headers.clear();
 158                         }
 159                         pathinfo = query = fragment = "";
 160                 }
 161         }
 162
 163         public URI getURI() {
 164                 return uri;
 165         }
 166
 167         public int timeout() {
 168                 return connectTimeout;
 169         }
 170
 171         protected HttpURLConnection getConnection(URI uri, StringBuilder pi) throws IOException, URISyntaxException {
 172                 URL url = new URI(
 173                                 uri.getScheme(),
 174                                 uri.getUserInfo(),
 175                                 uri.getHost(),
 176                                 uri.getPort(),
 177                                 pi==null?uri.getPath():pi.toString(),
 178                                 query,
 179                                 fragment).toURL();
 180                 return (HttpURLConnection) url.openConnection();
 181         }
 182
 183         public abstract class HFuture<T> extends Future<T> {
 184                 protected HttpURLConnection huc;
 185                 protected int respCode;
 186                 protected IOException exception;
 187                 protected StringBuilder errContent;
 188
 189                 public HFuture(final HttpURLConnection huc) {
 190                         this.huc = huc;
 191                 }
 192
 193                 protected boolean evalInfo(HttpURLConnection huc) throws APIException, IOException{
 194                         return respCode == 200;
 195                 };
 196
 197                 @Override
 198                 public final boolean get(int timeout) throws CadiException {
 199                         try {
 200                                 huc.setReadTimeout(timeout);
 201                                 respCode = huc.getResponseCode();
 202                                 ss.setLastResponse(respCode);
 203                                 if(evalInfo(huc)) {
 204                                         return true;
 205                                 } else {
 206                                         extractError();
 207                                         return false;
 208                                 }
 209                         } catch (IOException | APIException e) {
 210                                 throw new CadiException(e);
 211                         } finally {
 212                                 close();
 213                         }
 214                 }
 215
 216                 private void extractError() {
 217                         InputStream is = huc.getErrorStream();
 218                         try {
 219                                 if(is==null) {
 220                                         is = huc.getInputStream();
 221                                 }
 222                                 if(is!=null) {
 223                                 errContent = new StringBuilder();
 224                                 int c;
 225                                         while((c=is.read())>=0) {
 226                                                 errContent.append((char)c);
 227                                         }
 228                                 }
 229                         } catch (IOException e) {
 230                                 exception = e;
 231                         }
 232                 }
 233
 234                 // Typically only used by Read
 235                 public StringBuilder inputStreamToString(InputStream is) {
 236                         // Avoids Carriage returns, and is reasonably efficient, given
 237                         // the buffer reads.
 238                         try {
 239                                 StringBuilder sb = new StringBuilder();
 240                                 Reader rdr = new InputStreamReader(is);
 241                                 try {
 242                                         char[] buf = new char[256];
 243                                         int read;
 244                                         while ((read = rdr.read(buf)) >= 0) {
 245                                                 sb.append(buf, 0, read);
 246                                         }
 247                                 } finally {
 248                                         rdr.close();
 249                                 }
 250                                 return sb;
 251                         } catch (IOException e) {
 252                                 exception = e;
 253                                 return null;
 254                         }
 255                 }
 256
 257
 258                 @Override
 259                 public int code() {
 260                         return respCode;
 261                 }
 262
 263                 public HttpURLConnection huc() {
 264                         return huc;
 265                 }
 266
 267                 public IOException exception() {
 268                         return exception;
 269                 }
 270
 271                 @Override
 272                 public String header(String tag) {
 273                         return huc.getHeaderField(tag);
 274                 }
 275
 276                 public void close() {
 277                         if(huc!=null) {
 278                                 huc.disconnect();
 279                         }
 280                 }
 281         }
 282
 283         @Override
 284         public <T> Future<T> futureCreate(Class<T> t) {
 285                 return new HFuture<T>(huc) {
 286                         public boolean evalInfo(HttpURLConnection huc) {
 287                                 return respCode==201;
 288                         }
 289
 290                         @Override
 291                         public String body() {
 292                                 if (errContent != null) {
 293                                         return errContent.toString();
 294                                 }
 295                                 return "";
 296                         }
 297                 };
 298         }
 299
 300         @Override
 301         public Future<String> futureReadString() {
 302                 return new HFuture<String>(huc) {
 303                         public boolean evalInfo(HttpURLConnection huc) throws IOException {
 304                                 if (respCode == 200) {
 305                                         StringBuilder sb = inputStreamToString(huc.getInputStream());
 306                                         if (sb != null) {
 307                                                 value = sb.toString();
 308                                         }
 309                                         return true;
 310                                 }
 311                                 return false;
 312                         }
 313
 314                         @Override
 315                         public String body() {
 316                                 if (value != null) {
 317                                         return value;
 318                                 } else if (errContent != null) {
 319                                         return errContent.toString();
 320                                 }
 321                                 return "";
 322                         }
 323
 324                 };
 325         }
 326
 327         @Override
 328         public <T> Future<T> futureRead(final RosettaDF<T> df, final TYPE type) {
 329                 return new HFuture<T>(huc) {
 330                         private Data<T> data;
 331
 332                         public boolean evalInfo(HttpURLConnection huc) throws APIException, IOException {
 333                                 if (respCode == 200) {
 334                                         data = df.newData().in(type).load(huc.getInputStream());
 335                                         value = data.asObject();
 336                                         return true;
 337                                 }
 338                                 return false;
 339                         }
 340
 341                         @Override
 342                         public String body() {
 343                                 if (data != null) {
 344                                         try {
 345                                                 return data.asString();
 346                                         } catch (APIException e) {
 347                                         }
 348                                 } else if (errContent != null) {
 349                                         return errContent.toString();
 350                                 }
 351                                 return "";
 352                         }
 353                 };
 354         }
 355
 356         @Override
 357         public <T> Future<T> future(final T t) {
 358                 return new HFuture<T>(huc) {
 359                         public boolean evalInfo(HttpURLConnection huc) {
 360                                 if (respCode == 200) {
 361                                         value = t;
 362                                         return true;
 363                                 }
 364                                 return false;
 365                         }
 366
 367                         @Override
 368                         public String body() {
 369                                 if (errContent != null) {
 370                                         return errContent.toString();
 371                                 }
 372                                 return Integer.toString(respCode);
 373                         }
 374                 };
 375         }
 376
 377         @Override
 378         public Future<Void> future(final HttpServletResponse resp, final int expected) throws APIException {
 379                 return new HFuture<Void>(huc) {
 380                         public boolean evalInfo(HttpURLConnection huc) throws IOException, APIException {
 381                                 resp.setStatus(respCode);
 382                                 int read;
 383                                 InputStream is;
 384                                 OutputStream os = resp.getOutputStream();
 385                                 if(respCode==expected) {
 386                                         is = huc.getInputStream();
 387                                         // reuse Buffers
 388                                         Pooled<byte[]> pbuff = Rcli.buffPool.get();
 389                                         try {
 390                                                 while((read=is.read(pbuff.content))>=0) {
 391                                                         os.write(pbuff.content,0,read);
 392                                                 }
 393                                         } finally {
 394                                                 pbuff.done();
 395                                         }
 396                                         return true;
 397                                 } else {
 398                                         is = huc.getErrorStream();
 399                                         if(is==null) {
 400                                                 is = huc.getInputStream();
 401                                         }
 402                                         if(is!=null) {
 403                                                 errContent = new StringBuilder();
 404                                                 Pooled<byte[]> pbuff = Rcli.buffPool.get();
 405                                                 try {
 406                                                         while((read=is.read(pbuff.content))>=0) {
 407                                                                 os.write(pbuff.content,0,read);
 408                                                         }
 409                                                 } finally {
 410                                                         pbuff.done();
 411                                                 }
 412                                         }
 413                                 }
 414                                 return false;
 415                         }
 416
 417                         @Override
 418                         public String body() {
 419                                 return errContent==null?null:errContent.toString();
 420                         }
 421                 };
 422         }
 423
 424         private static class Header {
 425                 public final String tag;
 426                 public final String value;
 427
 428                 public Header(String t, String v) {
 429                         this.tag = t;
 430                         this.value = v;
 431                 }
 432
 433                 public String toString() {
 434                         return tag + '=' + value;
 435                 }
 436         }
 437
 438         public String toString() {
 439                 return "HttpURLConnection Client configured to " + uri.toString();
 440         }
 441 }