cadi/client/src/main/java/org/onap/aaf/cadi/client/Rcli.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.client;
  23
  24 import java.io.IOException;
  25 import java.io.OutputStream;
  26 import java.io.PrintStream;
  27 import java.net.URI;
  28 import java.util.Enumeration;
  29
  30 import javax.servlet.ServletInputStream;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.servlet.http.HttpServletResponse;
  33
  34 import org.onap.aaf.cadi.CadiException;
  35 import org.onap.aaf.cadi.SecuritySetter;
  36 import org.onap.aaf.cadi.client.EClient.Transfer;
  37 import org.onap.aaf.misc.env.APIException;
  38 import org.onap.aaf.misc.env.Data.TYPE;
  39 import org.onap.aaf.misc.env.util.Pool;
  40 import org.onap.aaf.misc.env.util.Pool.Pooled;
  41 import org.onap.aaf.misc.rosetta.env.RosettaDF;
  42
  43 public abstract class Rcli<CT> {
  44         public static final String FORM_ENCODED = "application/x-www-form-urlencoded";
  45         public static final String APPL_JSON = "application/json";
  46         public static final String APPL_XML = "application/xml";
  47         public static final String BLANK = "";
  48         public static final String CONTENT_TYPE = "Content-Type";
  49         public static final String ACCEPT = "Accept";
  50
  51         protected static final String POST = "POST";
  52         protected static final String GET = "GET";
  53         protected static final String PUT = "PUT";
  54         protected static final String DELETE = "DELETE";
  55         protected TYPE type;
  56         protected String apiVersion;
  57         protected int readTimeout = 5000;
  58         protected int connectionTimeout = 3000;
  59         protected URI uri;
  60         private String oneCallQueryParams;
  61         public static Pool<byte[]> buffPool = new Pool<byte[]>(new Pool.Creator<byte[]>() {
  62                 @Override
  63                 public byte[] create() throws APIException {
  64                         return new byte[1024];
  65                 }
  66
  67                 @Override
  68                 public void destroy(byte[] t) {
  69                 }
  70
  71                 @Override
  72                 public boolean isValid(byte[] t) {
  73                         return true;
  74                 }
  75
  76                 @Override
  77                 public void reuse(byte[] t) {
  78                 }
  79         });
  80
  81
  82         public Rcli() {
  83                 super();
  84         }
  85
  86         public abstract void setSecuritySetter(SecuritySetter<CT> ss);
  87         public abstract SecuritySetter<CT> getSecuritySetter();
  88
  89
  90         public Rcli<CT> forUser(SecuritySetter<CT> ss) {
  91                 Rcli<CT> rv = clone(uri==null?this.uri:uri,ss);
  92                 setSecuritySetter(ss);
  93                 rv.type = type;
  94                 rv.apiVersion = apiVersion;
  95                 return rv;
  96         }
  97
  98         protected abstract Rcli<CT> clone(URI uri, SecuritySetter<CT> ss);
  99
 100         public abstract void invalidate() throws CadiException;
 101
 102         public Rcli<CT> readTimeout(int millis) {
 103                 readTimeout = millis;
 104                 return this;
 105         }
 106
 107         public Rcli<CT> connectionTimeout(int millis) {
 108                 connectionTimeout = millis;
 109                 return this;
 110         }
 111
 112         public Rcli<CT> type(TYPE type) {
 113                 this.type=type;
 114                 return this;
 115         }
 116
 117         public Rcli<CT> apiVersion(String apiVersion) {
 118                 this.apiVersion = apiVersion;
 119                 return this;
 120         }
 121
 122         public boolean isApiVersion(String prospective) {
 123                 return apiVersion.equals(prospective);
 124         }
 125
 126
 127         public String typeString(Class<?> cls) {
 128                 return "application/"+cls.getSimpleName()+"+"+type.name().toLowerCase()+
 129                                 (apiVersion==null?BLANK:";version="+apiVersion);
 130         }
 131
 132         protected abstract EClient<CT> client() throws CadiException;
 133
 134
 135         public<T> Future<T> create(final String pathinfo, final String contentType, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 136                 final ParsePath pp = new ParsePath(pathinfo);
 137
 138                 EClient<CT> client = client();
 139                 client.setMethod(POST);
 140                 client.addHeader(CONTENT_TYPE,contentType);
 141                 client.setPathInfo(pp.path());
 142                 client.setQueryParams(pp.query());
 143                 client.setFragment(pp.frag());
 144                 client.setPayload(new EClient.Transfer() {
 145                         @Override
 146                         public void transfer(OutputStream os) throws IOException, APIException {
 147                                 df.newData().out(type).direct(t,os);
 148                         }
 149                 });
 150                 client.send();
 151                 return client.futureCreate(df.getTypeClass());
 152         }
 153
 154         public<T> Future<T> create(String pathinfo, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 155                 final ParsePath pp = new ParsePath(pathinfo);
 156
 157                 EClient<CT> client = client();
 158                 client.setMethod(POST);
 159                 client.addHeader(CONTENT_TYPE,typeString(df.getTypeClass()));
 160                 client.setPathInfo(pp.path());
 161                 client.setQueryParams(pp.query());
 162                 client.setFragment(pp.frag());
 163                 client.setPayload(new EClient.Transfer() {
 164                         @Override
 165                         public void transfer(OutputStream os) throws IOException, APIException {
 166                                 df.newData().out(type).direct(t,os);
 167                         }
 168                 });
 169                 client.send();
 170                 return client.futureCreate(df.getTypeClass());
 171         }
 172
 173         public<T> Future<T> create(String pathinfo, Class<?> cls, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 174                 final ParsePath pp = new ParsePath(pathinfo);
 175
 176                 EClient<CT> client = client();
 177                 client.setMethod(POST);
 178                 client.addHeader(CONTENT_TYPE,typeString(cls));
 179                 client.setPathInfo(pp.path());
 180                 client.setQueryParams(pp.query());
 181                 client.setFragment(pp.frag());
 182                 client.setPayload(new EClient.Transfer() {
 183                         @Override
 184                         public void transfer(OutputStream os) throws IOException, APIException {
 185                                 df.newData().out(type).direct(t,os);
 186                         }
 187                 });
 188                 client.send();
 189                 return client.futureCreate(df.getTypeClass());
 190         }
 191
 192         public<T> Future<T> create(String pathinfo, Class<T> cls) throws APIException, CadiException {
 193                 final ParsePath pp = new ParsePath(pathinfo);
 194
 195                 EClient<CT> client = client();
 196                 client.setMethod(POST);
 197                 client.addHeader(CONTENT_TYPE,typeString(cls));
 198                 client.setPathInfo(pp.path());
 199                 client.setQueryParams(pp.query());
 200                 client.setFragment(pp.frag());
 201                 client.setPayload(null);
 202                 client.send();
 203                 return client.futureCreate(cls);
 204         }
 205
 206         public Future<Void> create(String pathinfo, String contentType) throws APIException, CadiException {
 207                 final ParsePath pp = new ParsePath(pathinfo);
 208
 209                 EClient<CT> client = client();
 210                 client.setMethod(POST);
 211                 client.addHeader(CONTENT_TYPE,contentType);
 212                 client.setPathInfo(pp.path());
 213                 client.setQueryParams(pp.query());
 214                 client.setFragment(pp.frag());
 215                 client.setPayload(null);
 216                 client.send();
 217                 return client.futureCreate(Void.class);
 218         }
 219
 220         public Future<Void> create(String pathinfo, String contentType, EClient.Transfer content) throws APIException, CadiException {
 221                 final ParsePath pp = new ParsePath(pathinfo);
 222
 223                 EClient<CT> client = client();
 224                 client.setMethod(POST);
 225                 client.addHeader(CONTENT_TYPE,contentType);
 226                 client.setPathInfo(pp.path());
 227                 client.setQueryParams(pp.query());
 228                 client.setFragment(pp.frag());
 229                 client.setPayload(content);
 230                 client.send();
 231                 return client.futureCreate(Void.class);
 232         }
 233
 234
 235         /**
 236          * Post Data in WWW expected format, with the format tag1=value1&tag2=value2, etc
 237          * Note Shortcut:
 238          *   Because typically, you will want to have a variable as value, you can type, as long as tag ends with "="
 239          *   postForm(..., "tag1=value1","tag2=",var2);
 240          * @param pathinfo
 241          * @param df
 242          * @param cls
 243          * @param formParam
 244          * @return
 245          * @throws APIException
 246          * @throws CadiException
 247          */
 248         public <T> Future<T> postForm(String pathinfo, final RosettaDF<T> df, final String ... formParam) throws APIException, CadiException {
 249                 final ParsePath pp = new ParsePath(pathinfo);
 250
 251                 EClient<CT> client = client();
 252                 client.setMethod(POST);
 253                 client.addHeader(CONTENT_TYPE,FORM_ENCODED);
 254                 switch(type) {
 255                         case JSON:
 256                                 client.addHeader(ACCEPT, APPL_JSON);
 257                                 break;
 258                         case XML:
 259                                 client.addHeader(ACCEPT, APPL_XML);
 260                                 break;
 261                         default:
 262                                 break;
 263                 }
 264                 client.setPathInfo(pp.path());
 265                 client.setQueryParams(pp.query());
 266                 client.setFragment(pp.frag());
 267                 client.setPayload(new Transfer() {
 268                         @Override
 269                         public void transfer(OutputStream os) throws IOException, APIException {
 270                                 PrintStream ps;
 271                                 if(os instanceof PrintStream) {
 272                                         ps = (PrintStream)os;
 273                                 } else {
 274                                         ps = new PrintStream(os);
 275                                 }
 276                                 boolean first = true;
 277                                 for(String fp : formParam) {
 278                                         if(fp!=null) {
 279                                                 if(first) {
 280                                                         first = false;
 281                                                 } else {
 282                                                         ps.print('&');
 283                                                 }
 284                                                 if(fp.endsWith("=")) {
 285                                                         first = true;
 286                                                 }
 287                                                 ps.print(fp);
 288                                         }
 289                                 }
 290                         }});
 291                 client.send();
 292                 return client.futureRead(df,TYPE.JSON);
 293         }
 294
 295         /**
 296          * Read String, using POST for keyInfo
 297          *
 298          * @param pathinfo
 299          * @param df
 300          * @param t
 301          * @param resp
 302          * @return
 303          * @throws APIException
 304          * @throws CadiException
 305          */
 306         public<T> Future<String> readPost(String pathinfo, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 307                 final ParsePath pp = new ParsePath(pathinfo);
 308
 309                 EClient<CT> client = client();
 310                 client.setMethod(POST);
 311                 client.addHeader(CONTENT_TYPE,typeString(df.getTypeClass()));
 312                 client.setPathInfo(pp.path());
 313                 client.setQueryParams(pp.query());
 314                 client.setFragment(pp.frag());
 315                 client.setPayload(new EClient.Transfer() {
 316                         @Override
 317                         public void transfer(OutputStream os) throws IOException, APIException {
 318                                 df.newData().out(type).direct(t,os);
 319                         }
 320                 });
 321                 client.send();
 322                 return client.futureReadString();
 323         }
 324
 325         /**
 326          * Read using POST for keyInfo, responding with marshaled Objects
 327          *
 328          * @param pathinfo
 329          * @param df
 330          * @param t
 331          * @param resp
 332          * @return
 333          * @throws APIException
 334          * @throws CadiException
 335          */
 336         public<T,R> Future<R> readPost(String pathinfo, final RosettaDF<T> df, final T t, final RosettaDF<R> resp) throws APIException, CadiException {
 337                 final ParsePath pp = new ParsePath(pathinfo);
 338
 339                 EClient<CT> client = client();
 340                 client.setMethod(POST);
 341                 client.addHeader(CONTENT_TYPE,typeString(df.getTypeClass()));
 342                 client.setPathInfo(pp.path());
 343                 client.setQueryParams(pp.query());
 344                 client.setFragment(pp.frag());
 345                 client.setPayload(new EClient.Transfer() {
 346                         @Override
 347                         public void transfer(OutputStream os) throws IOException, APIException {
 348                                 df.newData().out(type).direct(t,os);
 349                         }
 350                 });
 351                 client.send();
 352                 return client.futureRead(resp,resp.getOutType());
 353         }
 354
 355         public Future<String> readPost(String pathinfo, String contentType, String ... headers) throws CadiException, APIException {
 356                 final ParsePath pp = new ParsePath(pathinfo);
 357
 358                 EClient<CT> client = client();
 359                 client.setMethod(POST);
 360                 client.addHeader(CONTENT_TYPE,contentType);
 361                 client.setPathInfo(pp.path());
 362                 client.setQueryParams(pp.query());
 363                 client.setFragment(pp.frag());
 364                 client.setPayload(new EClient.Transfer() {
 365                         @Override
 366                         public void transfer(OutputStream os) throws IOException, APIException {
 367                         }});
 368                 client.send();
 369                 return client.futureReadString();
 370         }
 371
 372         public Future<String> read(String pathinfo, String accept, String ... headers) throws APIException, CadiException {
 373                 final ParsePath pp = new ParsePath(pathinfo);
 374
 375                 EClient<CT> client = client();
 376                 client.setMethod(GET);
 377                 client.addHeader(ACCEPT, accept);
 378
 379                 for(int i=1;i<headers.length;i=i+2) {
 380                         client.addHeader(headers[i-1],headers[i]);
 381                 }
 382                 client.setPathInfo(pp.path());
 383                 client.setQueryParams(pp.query());
 384                 client.setFragment(pp.frag());
 385                 client.setPayload(null);
 386                 client.send();
 387                 return client.futureReadString();
 388         }
 389
 390         public<T> Future<T> read(String pathinfo, String accept, RosettaDF<T> df, String ... headers) throws APIException, CadiException {
 391                 final ParsePath pp = new ParsePath(pathinfo);
 392
 393                 EClient<CT> client = client();
 394                 client.setMethod(GET);
 395                 client.addHeader(ACCEPT, accept);
 396                 for(int i=1;i<headers.length;i=i+2) {
 397                         client.addHeader(headers[i-1],headers[i]);
 398                 }
 399                 client.setPathInfo(pp.path());
 400                 client.setQueryParams(pp.query());
 401                 client.setFragment(pp.frag());
 402                 client.setPayload(null);
 403                 client.send();
 404                 return client.futureRead(df,type);
 405         }
 406
 407         public<T> Future<T> read(String pathinfo, RosettaDF<T> df,String ... headers) throws APIException, CadiException {
 408                 final ParsePath pp = new ParsePath(pathinfo);
 409
 410                 EClient<CT> client = client();
 411                 client.setMethod(GET);
 412                 client.addHeader(ACCEPT, typeString(df.getTypeClass()));
 413                 for(int i=1;i<headers.length;i=i+2) {
 414                         client.addHeader(headers[i-1],headers[i]);
 415                 }
 416                 client.setPathInfo(pp.path());
 417                 client.setQueryParams(pp.query());
 418                 client.setFragment(pp.frag());
 419
 420                 client.setPayload(null);
 421                 client.send();
 422                 return client.futureRead(df,type);
 423         }
 424
 425         public<T> Future<T> read(String pathinfo, Class<?> cls, RosettaDF<T> df) throws APIException, CadiException {
 426                 final ParsePath pp = new ParsePath(pathinfo);
 427
 428                 EClient<CT> client = client();
 429                 client.setMethod(GET);
 430                 client.addHeader(ACCEPT, typeString(cls));
 431                 client.setPathInfo(pp.path());
 432                 client.setQueryParams(pp.query());
 433                 client.setFragment(pp.frag());
 434
 435                 client.setPayload(null);
 436                 client.send();
 437                 return client.futureRead(df,type);
 438         }
 439
 440         public<T> Future<T> update(String pathinfo, String contentType, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 441                 final ParsePath pp = new ParsePath(pathinfo);
 442
 443                 EClient<CT> client = client();
 444                 client.setMethod(PUT);
 445                 client.addHeader(CONTENT_TYPE,contentType);
 446                 client.setPathInfo(pp.path());
 447                 client.setQueryParams(pp.query());
 448                 client.setFragment(pp.frag());
 449                 client.setPayload(new EClient.Transfer() {
 450                         @Override
 451                         public void transfer(OutputStream os) throws IOException, APIException {
 452                                 df.newData().out(type).direct(t,os);
 453                         }
 454                 });
 455                 client.send();
 456                 return client.future(t);
 457         }
 458
 459         public<T> Future<String> updateRespondString(String pathinfo, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 460                 final ParsePath pp = new ParsePath(pathinfo);
 461
 462                 EClient<CT> client = client();
 463                 client.setMethod(PUT);
 464                 client.addHeader(CONTENT_TYPE, typeString(df.getTypeClass()));
 465                 client.setPathInfo(pp.path());
 466                 client.setQueryParams(pp.query());
 467                 client.setFragment(pp.frag());
 468
 469                 client.setPayload(new EClient.Transfer() {
 470                         @Override
 471                         public void transfer(OutputStream os) throws IOException, APIException {
 472                                 //String s = df.newData().out(type).load(t).asString();
 473                                 df.newData().out(type).direct(t,os);
 474                         }
 475                 });
 476                 client.send();
 477                 return client.futureReadString();
 478         }
 479
 480         public Future<String> update(String pathinfo, String contentType, EClient.Transfer content) throws APIException, CadiException {
 481                 final ParsePath pp = new ParsePath(pathinfo);
 482
 483                 EClient<CT> client = client();
 484                 client.setMethod(PUT);
 485                 client.addHeader(CONTENT_TYPE,contentType);
 486                 client.setPathInfo(pp.path());
 487                 client.setQueryParams(pp.query());
 488                 client.setFragment(pp.frag());
 489                 client.setPayload(content);
 490                 client.send();
 491                 return client.futureReadString();
 492         }
 493
 494
 495
 496
 497         public<T> Future<T> update(String pathinfo, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 498                 final ParsePath pp = new ParsePath(pathinfo);
 499
 500                 EClient<CT> client = client();
 501                 client.setMethod(PUT);
 502                 client.addHeader(CONTENT_TYPE, typeString(df.getTypeClass()));
 503                 client.setPathInfo(pp.path());
 504                 client.setQueryParams(pp.query());
 505                 client.setFragment(pp.frag());
 506
 507                 client.setPayload(new EClient.Transfer() {
 508                         @Override
 509                         public void transfer(OutputStream os) throws IOException, APIException {
 510                                 df.newData().out(type).direct(t,os);
 511                         }
 512                 });
 513                 client.send();
 514                 return client.future(t);
 515         }
 516
 517         public<T> Future<T> update(String pathinfo, Class<?> cls, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 518                 final ParsePath pp = new ParsePath(pathinfo);
 519
 520                 EClient<CT> client = client();
 521                 client.setMethod(PUT);
 522                 client.addHeader(CONTENT_TYPE, typeString(cls));
 523                 client.setPathInfo(pp.path());
 524                 client.setQueryParams(pp.query());
 525                 client.setFragment(pp.frag());
 526
 527                 client.setPayload(new EClient.Transfer() {
 528                         @Override
 529                         public void transfer(OutputStream os) throws IOException, APIException {
 530                                 df.newData().out(type).direct(t,os);
 531                         }
 532                 });
 533                 client.send();
 534                 return client.future(t);
 535         }
 536
 537
 538
 539         /**
 540          * A method to update with a VOID
 541          * @param pathinfo
 542          * @param resp
 543          * @param expected
 544          * @return
 545          * @throws APIException
 546          * @throws CadiException
 547          */
 548         public<T> Future<Void> update(String pathinfo) throws APIException, CadiException {
 549                 final ParsePath pp = new ParsePath(pathinfo);
 550
 551                 EClient<CT> client = client();
 552                 client.setMethod(PUT);
 553                 client.addHeader(CONTENT_TYPE, typeString(Void.class));
 554                 client.setPathInfo(pp.path());
 555                 client.setQueryParams(pp.query());
 556                 client.setFragment(pp.frag());
 557
 558 //              client.setPayload(new EClient.Transfer() {
 559 //                      @Override
 560 //                      public void transfer(OutputStream os) throws IOException, APIException {
 561 //                      }
 562 //              });
 563                 client.send();
 564                 return client.future(null);
 565         }
 566
 567
 568         public<T> Future<T> delete(String pathinfo, String contentType, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 569                 final ParsePath pp = new ParsePath(pathinfo);
 570
 571                 EClient<CT> client = client();
 572                 client.setMethod(DELETE);
 573                 client.addHeader(CONTENT_TYPE, contentType);
 574                 client.setPathInfo(pp.path());
 575                 client.setQueryParams(pp.query());
 576                 client.setFragment(pp.frag());
 577
 578                 client.setPayload(new EClient.Transfer() {
 579                         @Override
 580                         public void transfer(OutputStream os) throws IOException, APIException {
 581                                 df.newData().out(type).direct(t,os);
 582                         }
 583                 });
 584                 client.send();
 585                 return client.future(t);
 586         }
 587
 588         public<T> Future<T> delete(String pathinfo, Class<?> cls, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 589                 final ParsePath pp = new ParsePath(pathinfo);
 590
 591                 EClient<CT> client = client();
 592                 client.setMethod(DELETE);
 593                 client.addHeader(CONTENT_TYPE, typeString(cls));
 594                 client.setPathInfo(pp.path());
 595                 client.setQueryParams(pp.query());
 596                 client.setFragment(pp.frag());
 597                 client.setPayload(new EClient.Transfer() {
 598                         @Override
 599                         public void transfer(OutputStream os) throws IOException, APIException {
 600                                 df.newData().out(type).direct(t,os);
 601                         }
 602                 });
 603                 client.send();
 604                 return client.future(t);
 605         }
 606
 607         public<T> Future<T> delete(String pathinfo, final RosettaDF<T> df, final T t) throws APIException, CadiException {
 608                 final ParsePath pp = new ParsePath(pathinfo);
 609
 610                 EClient<CT> client = client();
 611                 client.setMethod(DELETE);
 612                 client.addHeader(CONTENT_TYPE, typeString(df.getTypeClass()));
 613                 client.setPathInfo(pp.path());
 614                 client.setQueryParams(pp.query());
 615                 client.setFragment(pp.frag());
 616                 client.setPayload(new EClient.Transfer() {
 617                         @Override
 618                         public void transfer(OutputStream os) throws IOException, APIException {
 619                                 df.newData().out(type).direct(t,os);
 620                         }
 621                 });
 622
 623                 client.send();
 624                 return client.future(t);
 625         }
 626
 627
 628         public<T> Future<T> delete(String pathinfo, Class<T> cls) throws APIException, CadiException {
 629                 final ParsePath pp = new ParsePath(pathinfo);
 630
 631                 EClient<CT> client = client();
 632                 client.setMethod(DELETE);
 633                 client.addHeader(CONTENT_TYPE, typeString(cls));
 634                 client.setPathInfo(pp.path());
 635                 client.setQueryParams(pp.query());
 636                 client.setFragment(pp.frag());
 637
 638                 client.setPayload(null);
 639                 client.send();
 640                 return client.future((T)null);
 641         }
 642
 643         public Future<Void> delete(String pathinfo, String contentType) throws APIException, CadiException {
 644                 final ParsePath pp = new ParsePath(pathinfo);
 645
 646                 EClient<CT> client = client();
 647                 client.setMethod(DELETE);
 648                 client.addHeader(CONTENT_TYPE, contentType);
 649                 client.setPathInfo(pp.path());
 650                 client.setQueryParams(pp.query());
 651                 client.setFragment(pp.frag());
 652
 653                 client.setPayload(null);
 654                 client.send();
 655                 return client.future(null);
 656         }
 657
 658         public Future<Void> transfer(final HttpServletRequest req, final HttpServletResponse resp, final String pathParam, final int expected) throws CadiException, APIException {
 659                 EClient<CT> client = client();
 660                 URI uri;
 661                 try {
 662                         uri = new URI(req.getRequestURI());
 663                 } catch (Exception e) {
 664                         throw new CadiException("Invalid incoming URI",e);
 665                 }
 666                 String name;
 667                 for(Enumeration<String> en = req.getHeaderNames();en.hasMoreElements();) {
 668                         name = en.nextElement();
 669                         client.addHeader(name,req.getHeader(name));
 670                 }
 671                 client.setQueryParams(req.getQueryString());
 672                 client.setFragment(uri.getFragment());
 673                 client.setPathInfo(pathParam);
 674                 String meth = req.getMethod();
 675                 client.setMethod(meth);
 676                 if(!"GET".equals(meth)) {
 677                         client.setPayload(new EClient.Transfer() {
 678                                 @Override
 679                                 public void transfer(OutputStream os) throws IOException, APIException {
 680                                         final ServletInputStream is = req.getInputStream();
 681                                         int read;
 682                                         // reuse Buffers
 683                                         Pooled<byte[]> pbuff = buffPool.get();
 684                                         try {
 685                                                 while((read=is.read(pbuff.content))>=0) {
 686                                                         os.write(pbuff.content,0,read);
 687                                                 }
 688                                         } finally {
 689                                                 pbuff.done();
 690                                         }
 691                                 }
 692                         });
 693                 }
 694                 client.send();
 695                 return client.future(resp, expected);
 696         }
 697
 698         private class ParsePath {
 699                 private final String path;
 700                 private final int query;
 701                 private final int queryEnd;
 702                 private final int pound;
 703                 private final String queryParams;
 704
 705                 public ParsePath(final String origPath) {
 706                         path = origPath;
 707                         if(origPath==null) {
 708                                 query=queryEnd=pound=-1;
 709                                 queryParams=null;
 710                         } else {
 711                                 query = origPath.indexOf('?');
 712                                 pound = origPath.indexOf('#');
 713                                 queryEnd = pound>=0?pound:path.length();
 714                                 if(oneCallQueryParams==null) {
 715                                         if(query>=0) {
 716                                                 queryParams = path.substring(query+1,queryEnd);
 717                                         } else {
 718                                                 queryParams=null;
 719                                         }
 720                                 } else {
 721                                         if(query>=0) {
 722                                                 queryParams = oneCallQueryParams + '&' + path.substring(query+1,queryEnd);
 723                                         } else {
 724                                                 queryParams = oneCallQueryParams;
 725                                         }
 726                                         oneCallQueryParams = null;
 727                                 }
 728                         }
 729                 }
 730
 731                 public String path() {
 732                         if(query>=0) {
 733                                 if(pound>=0) {
 734                                         return path.substring(pound+1);
 735                                 }
 736                                 return path.substring(0,query);
 737                         } else if(pound>=0) {
 738                                 return path.substring(0,pound);
 739                         } else {
 740                                 return path;
 741                         }
 742                 }
 743
 744                 public String query() {
 745                         return queryParams;
 746                 }
 747
 748                 public String frag() {
 749                         if(pound>=0) {
 750                                 return path.substring(pound+1);
 751                         } else {
 752                                 return null;
 753                         }
 754                 }
 755         }
 756
 757         public String toString() {
 758                 return uri.toString();
 759         }
 760
 761         public URI getURI() {
 762                 return uri;
 763         }
 764
 765         public void setQueryParams(final String queryParams) {
 766                 oneCallQueryParams=queryParams;
 767         }
 768
 769 }