HttpConfigs.java

  1. /**
  2.  * Copyright (C) 2017 HttpBuilder-NG Project
  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 groovyx.net.http;

  18. import groovyx.net.http.optional.Csv;
  19. import groovyx.net.http.optional.Html;

  21. import java.io.IOException;
  22. import java.net.HttpCookie;
  23. import java.net.URI;
  24. import java.net.URISyntaxException;
  25. import java.net.URL;
  26. import java.nio.charset.Charset;
  27. import java.nio.charset.StandardCharsets;
  28. import java.time.Instant;
  29. import java.time.LocalDateTime;
  30. import java.time.ZoneId;
  31. import java.util.AbstractMap;
  32. import java.util.ArrayList;
  33. import java.util.Date;
  34. import java.util.LinkedHashMap;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.concurrent.ConcurrentHashMap;
  38. import java.util.concurrent.ConcurrentMap;
  39. import java.util.concurrent.CopyOnWriteArrayList;
  40. import java.util.function.BiConsumer;
  41. import java.util.function.BiFunction;
  42. import java.util.function.Function;

  44. import static groovyx.net.http.ChainedHttpConfig.Auth;
  45. import static groovyx.net.http.ChainedHttpConfig.AuthType;
  46. import static groovyx.net.http.ChainedHttpConfig.ChainedRequest;
  47. import static groovyx.net.http.ChainedHttpConfig.ChainedResponse;
  48. import static groovyx.net.http.ContentTypes.BINARY;
  49. import static groovyx.net.http.ContentTypes.JSON;
  50. import static groovyx.net.http.ContentTypes.TEXT;
  51. import static groovyx.net.http.ContentTypes.URLENC;
  52. import static groovyx.net.http.ContentTypes.XML;
  53. import static groovyx.net.http.Safe.ifClassIsLoaded;
  54. import static groovyx.net.http.Safe.register;

  56. public class HttpConfigs {

  58.     public static class BasicAuth implements Auth {
  59.         private String user;
  60.         private String password;
  61.         private boolean preemptive;
  62.         private AuthType authType;

  64.         public void basic(final String user, final String password, final boolean preemptive) {
  65.             this.user = user;
  66.             this.password = password;
  67.             this.preemptive = preemptive;
  68.             this.authType = AuthType.BASIC;
  69.         }

  71.         public void digest(final String user, final String password, final boolean preemptive) {
  72.             basic(user, password, preemptive);
  73.             this.authType = AuthType.DIGEST;
  74.         }

  76.         public String getUser() {
  77.             return user;
  78.         }

  80.         public String getPassword() {
  81.             return password;
  82.         }

  84.         public AuthType getAuthType() {
  85.             return authType;
  86.         }
  87.     }

  89.     public static class ThreadSafeAuth implements Auth {
  90.         volatile String user;
  91.         volatile String password;
  92.         volatile boolean preemptive;
  93.         volatile AuthType authType;

  95.         public ThreadSafeAuth() { }

  97.         public ThreadSafeAuth(final BasicAuth toCopy) {
  98.             this.user = toCopy.user;
  99.             this.password = toCopy.password;
  100.             this.preemptive = toCopy.preemptive;
  101.             this.authType = toCopy.authType;
  102.         }

  104.         public void basic(final String user, final String password, final boolean preemptive) {
  105.             this.user = user;
  106.             this.password = password;
  107.             this.preemptive = preemptive;
  108.             this.authType = AuthType.BASIC;
  109.         }

  111.         public void digest(final String user, final String password, final boolean preemptive) {
  112.             basic(user, password, preemptive);
  113.             this.authType = AuthType.DIGEST;
  114.         }

  116.         public String getUser() {
  117.             return user;
  118.         }

  120.         public String getPassword() {
  121.             return password;
  122.         }

  124.         public AuthType getAuthType() {
  125.             return authType;
  126.         }
  127.     }

  129.     public static abstract class BaseRequest implements ChainedRequest {

  131.         final ChainedRequest parent;
  132.         HttpVerb verb;

  134.         public BaseRequest(final ChainedRequest parent) {
  135.             this.parent = parent;
  136.         }

  138.         public ChainedRequest getParent() {
  139.             return parent;
  140.         }

  142.         public void setCharset(final String val) {
  143.             setCharset(Charset.forName(val));
  144.         }

  146.         public void setUri(final String val) {
  147.             getUri().setFull(val);
  148.         }

  150.         public void setRaw(final String val){
  151.             UriBuilder uriBuilder = getUri();
  152.             uriBuilder.setUseRawValues(true);
  153.             uriBuilder.setFull(val);
  154.         }

  156.         public void setUri(final URI val) {
  157.             getUri().setFull(val);
  158.         }

  160.         public void setUri(final URL val) throws URISyntaxException {
  161.             getUri().setFull(val.toURI());
  162.         }

  164.         public BiConsumer<ChainedHttpConfig,ToServer> encoder(final String contentType) {
  165.             final BiConsumer<ChainedHttpConfig,ToServer> enc =  getEncoderMap().get(contentType);
  166.             return enc != null ? enc : null;
  167.         }

  169.         public void encoder(final String contentType, final BiConsumer<ChainedHttpConfig,ToServer> val) {
  170.             getEncoderMap().put(contentType, val);
  171.         }

  173.         public void encoder(final Iterable<String> contentTypes, final BiConsumer<ChainedHttpConfig,ToServer> val) {
  174.             for(String contentType : contentTypes) {
  175.                 encoder(contentType, val);
  176.             }
  177.         }

  179.         public void setAccept(final String[] values) {
  180.             getHeaders().put("Accept", String.join(";", values));
  181.         }

  183.         public void setAccept(final Iterable<String> values) {
  184.             getHeaders().put("Accept", String.join(";", values));
  185.         }

  187.         public void setHeaders(final Map<String,CharSequence> toAdd) {
  188.             final Map<String,CharSequence> h = getHeaders();
  189.             if(toAdd != null){
  190.                 for(final Map.Entry<String,CharSequence> entry : toAdd.entrySet()) {
  191.                     h.put(entry.getKey(), entry.getValue());
  192.                 }
  193.             }
  194.         }

  196.         public void cookie(final String name, final String value, final Instant instant) {
  197.             final HttpCookie cookie = new HttpCookie(name, value);
  198.             cookie.setPath("/");
  199.             final Instant now = Instant.now();
  200.             if(instant != null && now.isBefore(instant)) {
  201.                 cookie.setMaxAge(instant.getEpochSecond() - now.getEpochSecond());
  202.             }

  204.             getCookies().add(cookie);
  205.         }

  207.         public void cookie(final String name, final String value, final Date date) {
  208.             cookie(name, value, date == null ? (Instant) null : date.toInstant());
  209.         }

  211.         public void cookie(final String name, final String value, final LocalDateTime dateTime){
  212.             cookie(name, value, dateTime == null ? (Instant) null : dateTime.atZone(ZoneId.systemDefault()).toInstant());
  213.         }

  215.         @Override
  216.         public HttpVerb getVerb() {
  217.             return verb;
  218.         }

  220.         @Override
  221.         public void setVerb(final HttpVerb verb) {
  222.             this.verb = verb;
  223.         }
  224.     }

  226.     public static class BasicRequest extends BaseRequest {
  227.         private String contentType;
  228.         private Charset charset;
  229.         private UriBuilder uriBuilder;
  230.         private final Map<String, CharSequence> headers = new LinkedHashMap<>();
  231.         private Object body;
  232.         private final Map<String,BiConsumer<ChainedHttpConfig,ToServer>> encoderMap = new LinkedHashMap<>();
  233.         private BasicAuth auth = new BasicAuth();
  234.         private List<HttpCookie> cookies = new ArrayList<>(1);

  236.         protected BasicRequest(ChainedRequest parent) {
  237.             super(parent);
  238.             this.uriBuilder = (parent == null) ? UriBuilder.basic(null) : UriBuilder.basic(parent.getUri());
  239.         }

  241.         public Map<String,BiConsumer<ChainedHttpConfig,ToServer>> getEncoderMap() {
  242.             return encoderMap;
  243.         }

  245.         public List<HttpCookie> getCookies() {
  246.             return cookies;
  247.         }

  249.         public String getContentType() {
  250.             return contentType;
  251.         }

  253.         public void setContentType(final String val) {
  254.             this.contentType = val;
  255.         }

  257.         public void setCharset(final Charset val) {
  258.             this.charset = val;
  259.         }

  261.         public Charset getCharset() {
  262.             return charset;
  263.         }

  265.         public UriBuilder getUri() {
  266.             return uriBuilder;
  267.         }

  269.         public Map<String,CharSequence> getHeaders() {
  270.             return headers;
  271.         }

  273.         public Object getBody() {
  274.             return body;
  275.         }

  277.         public void setBody(Object val) {
  278.             this.body = val;
  279.         }

  281.         public BasicAuth getAuth() {
  282.             return auth;
  283.         }
  284.     }

  286.     public static class ThreadSafeRequest extends BaseRequest {

  288.         private volatile String contentType;
  289.         private volatile Charset charset;
  290.         private volatile UriBuilder uriBuilder;
  291.         private final ConcurrentMap<String,CharSequence> headers = new ConcurrentHashMap<>();
  292.         private volatile Object body;
  293.         private final ConcurrentMap<String,BiConsumer<ChainedHttpConfig,ToServer>> encoderMap = new ConcurrentHashMap<>();
  294.         private final ThreadSafeAuth auth;
  295.         private final List<HttpCookie> cookies = new CopyOnWriteArrayList<>();

  297.         public ThreadSafeRequest(final ChainedRequest parent) {
  298.             super(parent);
  299.             this.auth = new ThreadSafeAuth();
  300.             this.uriBuilder = (parent == null) ? UriBuilder.threadSafe(null) : UriBuilder.threadSafe(parent.getUri());
  301.         }

  303.         public List<HttpCookie> getCookies() {
  304.             return cookies;
  305.         }

  307.         public Map<String,BiConsumer<ChainedHttpConfig,ToServer>> getEncoderMap() {
  308.             return encoderMap;
  309.         }

  311.         public String getContentType() {
  312.             return contentType;
  313.         }

  315.         public void setContentType(final String val) {
  316.             this.contentType = val;
  317.         }

  319.         public Charset getCharset() {
  320.             return charset;
  321.         }

  323.         public void setCharset(final Charset val) {
  324.             this.charset = val;
  325.         }

  327.         public UriBuilder getUri() {
  328.             return uriBuilder;
  329.         }

  331.         public Map<String,CharSequence> getHeaders() {
  332.             return headers;
  333.         }

  335.         public Object getBody() {
  336.             return body;
  337.         }

  339.         public void setBody(Object val) {
  340.             this.body = val;
  341.         }

  343.         public ThreadSafeAuth getAuth() {
  344.             return auth;
  345.         }
  346.     }

  348.     public static abstract class BaseResponse implements ChainedResponse {

  350.         abstract protected Map<Integer,BiFunction<FromServer, Object, ?>> getByCode();
  351.         abstract protected BiFunction<FromServer, Object, ?> getSuccess();
  352.         abstract protected BiFunction<FromServer, Object, ?> getFailure();
  353.         abstract protected Map<String,BiFunction<ChainedHttpConfig,FromServer,Object>> getParserMap();

  355.         private final ChainedResponse parent;

  357.         public ChainedResponse getParent() {
  358.             return parent;
  359.         }

  361.         protected BaseResponse(final ChainedResponse parent) {
  362.             this.parent = parent;
  363.         }

  365.         public void when(String code, BiFunction<FromServer, Object, ?> closure) {
  366.             when(Integer.valueOf(code), closure);
  367.         }

  369.         public void when(Integer code, BiFunction<FromServer, Object, ?> closure) {
  370.             getByCode().put(code, closure);
  371.         }

  373.         public void when(final HttpConfig.Status status, final BiFunction<FromServer, Object, ?> closure) {
  374.             if(status == HttpConfig.Status.SUCCESS) {
  375.                 success(closure);
  376.             } else {
  377.                 failure(closure);
  378.             }
  379.         }

  381.         public BiFunction<FromServer, Object, ?> when(final Integer code) {
  382.             if(getByCode().containsKey(code)) {
  383.                 return getByCode().get(code);
  384.             }

  386.             if(code < 400 && getSuccess() != null) {
  387.                 return getSuccess();
  388.             }

  390.             if(code >= 400 && getFailure() != null) {
  391.                 return getFailure();
  392.             }

  394.             return null;
  395.         }

  397.         public BiFunction<ChainedHttpConfig,FromServer,Object> parser(final String contentType) {
  398.             final BiFunction<ChainedHttpConfig,FromServer,Object> p = getParserMap().get(contentType);
  399.             return p != null ? p : null;
  400.         }

  402.         public void parser(final String contentType, BiFunction<ChainedHttpConfig,FromServer,Object> val) {
  403.             getParserMap().put(contentType, val);
  404.         }

  406.         public void parser(final Iterable<String> contentTypes, BiFunction<ChainedHttpConfig,FromServer,Object> val) {
  407.             for(String contentType : contentTypes) {
  408.                 parser(contentType, val);
  409.             }
  410.         }

  412.         public abstract void setType(Class<?> type);
  413.     }

  415.     public static class BasicResponse extends BaseResponse {

  417.         private final Map<Integer,BiFunction<FromServer, Object, ?>> byCode = new LinkedHashMap<>();
  418.         private BiFunction<FromServer, Object, ?> successHandler;
  419.         private BiFunction<FromServer, Object, ?> failureHandler;
  420.         private Function<Throwable,?> exceptionHandler;
  421.         private final Map<String,BiFunction<ChainedHttpConfig,FromServer,Object>> parserMap = new LinkedHashMap<>();
  422.         private Class<?> type = Object.class;

  424.         protected BasicResponse(final ChainedResponse parent) {
  425.             super(parent);
  426.         }

  428.         public Map<String,BiFunction<ChainedHttpConfig,FromServer,Object>> getParserMap() {
  429.             return parserMap;
  430.         }

  432.         protected Map<Integer,BiFunction<FromServer, Object, ?>> getByCode() {
  433.             return byCode;
  434.         }

  436.         protected BiFunction<FromServer, Object, ?> getSuccess() {
  437.             return successHandler;
  438.         }

  440.         protected BiFunction<FromServer, Object, ?> getFailure() {
  441.             return failureHandler;
  442.         }

  444.         public Function<Throwable,?> getException() {
  445.             return exceptionHandler;
  446.         }

  448.         public void success(final BiFunction<FromServer, Object, ?> val) {
  449.             successHandler = val;
  450.         }

  452.         public void failure(final BiFunction<FromServer, Object, ?> val) {
  453.             failureHandler = val;
  454.         }

  456.         public void exception(final Function<Throwable,?> val) {
  457.             exceptionHandler = val;
  458.         }

  460.         public Class<?> getType() {
  461.             return type;
  462.         }

  464.         public void setType(Class<?> val) {
  465.             type = val;
  466.         }
  467.     }

  469.     public static class ThreadSafeResponse extends BaseResponse {

  471.         private final ConcurrentMap<String,BiFunction<ChainedHttpConfig,FromServer,Object>> parserMap = new ConcurrentHashMap<>();
  472.         private final ConcurrentMap<Integer,BiFunction<FromServer, Object, ?>> byCode = new ConcurrentHashMap<>();
  473.         private volatile BiFunction<FromServer, Object, ?> successHandler;
  474.         private volatile BiFunction<FromServer, Object, ?> failureHandler;
  475.         private volatile Function<Throwable,?> exceptionHandler;
  476.         private volatile Class<?> type = Object.class;

  478.         public ThreadSafeResponse(final ChainedResponse parent) {
  479.             super(parent);
  480.         }

  482.         protected Map<String,BiFunction<ChainedHttpConfig,FromServer,Object>> getParserMap() {
  483.             return parserMap;
  484.         }

  486.         protected Map<Integer,BiFunction<FromServer, Object, ?>> getByCode() {
  487.             return byCode;
  488.         }

  490.         protected BiFunction<FromServer, Object, ?> getSuccess() {
  491.             return successHandler;
  492.         }

  494.         protected BiFunction<FromServer, Object, ?> getFailure() {
  495.             return failureHandler;
  496.         }

  498.         public Function<Throwable,?> getException() {
  499.             return exceptionHandler;
  500.         }

  502.         public void success(final BiFunction<FromServer, Object, ?> val) {
  503.             successHandler = val;
  504.         }

  506.         public void failure(final BiFunction<FromServer, Object, ?> val) {
  507.             failureHandler = val;
  508.         }

  510.         public void exception(final Function<Throwable,?> val) {
  511.             this.exceptionHandler = val;
  512.         }

  514.         public Class<?> getType() {
  515.             return type;
  516.         }

  518.         public void setType(final Class<?> val) {
  519.             type = val;
  520.         }
  521.     }

  523.     public abstract static class BaseHttpConfig implements ChainedHttpConfig {

  525.         private final ChainedHttpConfig parent;

  527.         public BaseHttpConfig(ChainedHttpConfig parent) {
  528.             this.parent = parent;
  529.         }

  531.         public ChainedHttpConfig getParent() {
  532.             return parent;
  533.         }

  535.         public ChainedHttpConfig configure() {
  536.             getRequest().setCharset(StandardCharsets.UTF_8);
  537.             getRequest().encoder(BINARY, NativeHandlers.Encoders::binary);
  538.             getRequest().encoder(TEXT, (f,s) -> {
  539.                     try {
  540.                         NativeHandlers.Encoders.text(f, s);
  541.                     }
  542.                     catch(IOException e) {
  543.                         throw new TransportingException(e);
  544.                     } });

  546.             getRequest().encoder(URLENC, NativeHandlers.Encoders::form);
  547.             getRequest().encoder(XML, NativeHandlers.Encoders::xml);
  548.             getRequest().encoder(JSON, NativeHandlers.Encoders::json);

  550.             getResponse().success(NativeHandlers::success);
  551.             getResponse().failure(NativeHandlers::failure);
  552.             getResponse().exception(NativeHandlers::exception);

  554.             getResponse().parser(BINARY, NativeHandlers.Parsers::streamToBytes);
  555.             getResponse().parser(TEXT, NativeHandlers.Parsers::textToString);
  556.             getResponse().parser(URLENC, NativeHandlers.Parsers::form);
  557.             getResponse().parser(XML, NativeHandlers.Parsers::xml);
  558.             getResponse().parser(JSON, NativeHandlers.Parsers::json);

  560.             return this;
  561.         }

  563.         public void context(final String contentType, final Object id, final Object obj) {
  564.             getContextMap().put(new AbstractMap.SimpleImmutableEntry<>(contentType, id), obj);
  565.         }
  566.     }

  568.     public static class ThreadSafeHttpConfig extends BaseHttpConfig {
  569.         private final ThreadSafeRequest request;
  570.         private final ThreadSafeResponse response;
  571.         private final ConcurrentMap<Map.Entry<String,Object>,Object> contextMap = new ConcurrentHashMap<>();

  573.         public ThreadSafeHttpConfig(final ChainedHttpConfig parent) {
  574.             super(parent);
  575.             if(parent == null) {
  576.                 this.request = new ThreadSafeRequest(null);
  577.                 this.response = new ThreadSafeResponse(null);
  578.             }
  579.             else {
  580.                 this.request = new ThreadSafeRequest(parent.getChainedRequest());
  581.                 this.response = new ThreadSafeResponse(parent.getChainedResponse());
  582.             }
  583.         }

  585.         public Request getRequest() {
  586.             return request;
  587.         }

  589.         public Response getResponse() {
  590.             return response;
  591.         }

  593.         public ChainedRequest getChainedRequest() {
  594.             return request;
  595.         }

  597.         public ChainedResponse getChainedResponse() {
  598.             return response;
  599.         }

  601.         public Map<Map.Entry<String,Object>,Object> getContextMap() {
  602.             return contextMap;
  603.         }
  604.     }

  606.     public static class BasicHttpConfig extends BaseHttpConfig {
  607.         private final BasicRequest request;
  608.         private final BasicResponse response;
  609.         private final Map<Map.Entry<String,Object>,Object> contextMap = new LinkedHashMap<>(1);

  611.         public BasicHttpConfig(final ChainedHttpConfig parent) {
  612.             super(parent);
  613.             if(parent == null) {
  614.                 this.request = new BasicRequest(null);
  615.                 this.response = new BasicResponse(null);
  616.             }
  617.             else {
  618.                 this.request = new BasicRequest(parent.getChainedRequest());
  619.                 this.response = new BasicResponse(parent.getChainedResponse());
  620.             }
  621.         }

  623.         public BasicRequest getRequest() {
  624.             return request;
  625.         }

  627.         public BasicResponse getResponse() {
  628.             return response;
  629.         }

  631.         public BasicRequest getChainedRequest() {
  632.             return request;
  633.         }

  635.         public BasicResponse getChainedResponse() {
  636.             return response;
  637.         }

  639.         public Map<Map.Entry<String,Object>,Object> getContextMap() {
  640.             return contextMap;
  641.         }
  642.     }

  644.     private static final ThreadSafeHttpConfig root;

  646.     static {
  647.         root = (ThreadSafeHttpConfig) new ThreadSafeHttpConfig(null).configure();

  649.         register(root, ifClassIsLoaded("org.cyberneko.html.parsers.SAXParser"),
  650.                  "text/html", () -> NativeHandlers.Encoders::xml, Html.neckoParserSupplier);

  652.         register(root, ifClassIsLoaded("org.jsoup.Jsoup"),
  653.                  "text/html", Html.jsoupEncoderSupplier, Html.jsoupParserSupplier);

  655.         if(register(root, ifClassIsLoaded("com.opencsv.CSVReader"),
  656.                     "text/csv", Csv.encoderSupplier, Csv.parserSupplier)) {
  657.             root.context("text/csv", Csv.Context.ID, Csv.Context.DEFAULT_CSV);
  658.         }

  660.         if(register(root, ifClassIsLoaded("com.opencsv.CSVReader"),
  661.                     "text/tab-separated-values", Csv.encoderSupplier, Csv.parserSupplier)) {
  662.             root.context("text/tab-separated-values", Csv.Context.ID, Csv.Context.DEFAULT_TSV);
  663.         }
  664.     }

  666.     public static ChainedHttpConfig root() {
  667.         return root;
  668.     }

  670.     public static ChainedHttpConfig threadSafe(final ChainedHttpConfig parent) {
  671.         return new ThreadSafeHttpConfig(parent);
  672.     }

  674.     public static ChainedHttpConfig classLevel(final boolean threadSafe) {
  675.         return threadSafe ? threadSafe(root) : basic(root);
  676.     }

  678.     public static ChainedHttpConfig basic(final ChainedHttpConfig parent) {
  679.         return new BasicHttpConfig(parent);
  680.     }

  682.     public static BasicHttpConfig requestLevel(final ChainedHttpConfig parent) {
  683.         return new BasicHttpConfig(parent);
  684.     }
  685. }
Created with JaCoCo 0.7.9.201702052155