Add HTTP header classes. Project: http://git-wip-us.apache.org/repos/asf/incubator-juneau/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-juneau/commit/fa4736b6 Tree: http://git-wip-us.apache.org/repos/asf/incubator-juneau/tree/fa4736b6 Diff: http://git-wip-us.apache.org/repos/asf/incubator-juneau/diff/fa4736b6
Branch: refs/heads/master Commit: fa4736b6df552a5fd4dc624b51d4ae7431dbfcda Parents: de98f18 Author: JamesBognar <[email protected]> Authored: Sat May 6 12:24:28 2017 -0400 Committer: JamesBognar <[email protected]> Committed: Sat May 6 12:24:28 2017 -0400 ---------------------------------------------------------------------- .../juneau/https/AcceptExtensionsTest.java | 18 +- .../java/org/apache/juneau/BeanContext.java | 2 +- .../java/org/apache/juneau/http/Accept.java | 220 +++++++-------- .../org/apache/juneau/http/AcceptCharset.java | 82 ++++++ .../org/apache/juneau/http/AcceptEncoding.java | 181 +++++------- .../org/apache/juneau/http/AcceptLanguage.java | 110 ++++++++ .../org/apache/juneau/http/AcceptRanges.java | 69 +++++ .../main/java/org/apache/juneau/http/Age.java | 64 +++++ .../main/java/org/apache/juneau/http/Allow.java | 72 +++++ .../org/apache/juneau/http/Authorization.java | 78 ++++++ .../org/apache/juneau/http/CacheControl.java | 102 +++++++ .../java/org/apache/juneau/http/Connection.java | 106 +++++++ .../java/org/apache/juneau/http/Constants.java | 21 ++ .../org/apache/juneau/http/ContentEncoding.java | 74 +++++ .../apache/juneau/http/ContentEncodingEnum.java | 34 +++ .../org/apache/juneau/http/ContentLanguage.java | 78 ++++++ .../org/apache/juneau/http/ContentLength.java | 67 +++++ .../org/apache/juneau/http/ContentLocation.java | 72 +++++ .../org/apache/juneau/http/ContentRange.java | 126 +++++++++ .../org/apache/juneau/http/ContentType.java | 58 ++-- .../main/java/org/apache/juneau/http/Date.java | 83 ++++++ .../main/java/org/apache/juneau/http/ETag.java | 58 ++++ .../org/apache/juneau/http/EntityValidator.java | 72 +++++ .../java/org/apache/juneau/http/Expect.java | 73 +++++ .../java/org/apache/juneau/http/Expires.java | 80 ++++++ .../main/java/org/apache/juneau/http/From.java | 72 +++++ .../java/org/apache/juneau/http/HeaderDate.java | 51 ++++ .../juneau/http/HeaderEntityValidator.java | 47 ++++ .../juneau/http/HeaderEntityValidatorArray.java | 55 ++++ .../java/org/apache/juneau/http/HeaderEnum.java | 70 +++++ .../org/apache/juneau/http/HeaderInteger.java | 59 ++++ .../apache/juneau/http/HeaderRangeArray.java | 74 +++++ .../org/apache/juneau/http/HeaderString.java | 72 +++++ .../apache/juneau/http/HeaderStringArray.java | 80 ++++++ .../java/org/apache/juneau/http/HeaderUri.java | 62 +++++ .../main/java/org/apache/juneau/http/Host.java | 75 +++++ .../java/org/apache/juneau/http/IfMatch.java | 90 ++++++ .../org/apache/juneau/http/IfModifiedSince.java | 92 +++++++ .../org/apache/juneau/http/IfNoneMatch.java | 95 +++++++ .../java/org/apache/juneau/http/IfRange.java | 95 +++++++ .../apache/juneau/http/IfUnmodifiedSince.java | 66 +++++ .../org/apache/juneau/http/LastModified.java | 74 +++++ .../java/org/apache/juneau/http/Location.java | 63 +++++ .../org/apache/juneau/http/MaxForwards.java | 65 +++++ .../java/org/apache/juneau/http/Pragma.java | 71 +++++ .../apache/juneau/http/ProxyAuthenticate.java | 58 ++++ .../apache/juneau/http/ProxyAuthorization.java | 60 ++++ .../main/java/org/apache/juneau/http/Range.java | 136 +++++++++ .../java/org/apache/juneau/http/Referer.java | 65 +++++ .../java/org/apache/juneau/http/RetryAfter.java | 94 +++++++ .../java/org/apache/juneau/http/Server.java | 65 +++++ .../org/apache/juneau/http/StringRange.java | 276 +++++++++++++++++++ .../main/java/org/apache/juneau/http/TE.java | 97 +++++++ .../java/org/apache/juneau/http/Trailer.java | 65 +++++ .../apache/juneau/http/TransferEncoding.java | 64 +++++ .../java/org/apache/juneau/http/TypeRange.java | 276 ------------------- .../java/org/apache/juneau/http/Upgrade.java | 84 ++++++ .../java/org/apache/juneau/http/UserAgent.java | 60 ++++ .../main/java/org/apache/juneau/http/Vary.java | 78 ++++++ .../main/java/org/apache/juneau/http/Via.java | 115 ++++++++ .../java/org/apache/juneau/http/Warning.java | 123 +++++++++ .../org/apache/juneau/http/WwwAuthenticate.java | 56 ++++ .../java/org/apache/juneau/internal/Cache.java | 81 ++++++ .../org/apache/juneau/internal/DateUtils.java | 186 +++++++++++++ .../org/apache/juneau/internal/StringUtils.java | 16 ++ .../java/org/apache/juneau/xml/XmlParser.java | 1 + 66 files changed, 4939 insertions(+), 545 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core-test/src/test/java/org/apache/juneau/https/AcceptExtensionsTest.java ---------------------------------------------------------------------- diff --git a/juneau-core-test/src/test/java/org/apache/juneau/https/AcceptExtensionsTest.java b/juneau-core-test/src/test/java/org/apache/juneau/https/AcceptExtensionsTest.java index be8b0f0..6a7b0d3 100644 --- a/juneau-core-test/src/test/java/org/apache/juneau/https/AcceptExtensionsTest.java +++ b/juneau-core-test/src/test/java/org/apache/juneau/https/AcceptExtensionsTest.java @@ -32,7 +32,7 @@ public class AcceptExtensionsTest { MediaTypeRange mr; accept = Accept.forString("text/json"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json", mr); assertTextEquals("text/json", mr.getMediaType()); assertObjectEquals("{}", mr.getMediaType().getParameters()); @@ -40,7 +40,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString("foo,bar"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("foo", mr); assertTextEquals("foo", mr.getMediaType()); assertObjectEquals("{}", mr.getMediaType().getParameters()); @@ -48,7 +48,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString(" foo , bar "); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("foo", mr); assertTextEquals("foo", mr.getMediaType()); assertObjectEquals("{}", mr.getMediaType().getParameters()); @@ -56,7 +56,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString("text/json;a=1;q=0.9;b=2"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;a=1;q=0.9;b=2", mr); assertTextEquals("text/json;a=1", mr.getMediaType()); assertObjectEquals("{a:['1']}", mr.getMediaType().getParameters()); @@ -64,7 +64,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{b:['2']}", mr.getExtensions()); accept = Accept.forString("text/json;a=1;a=2;q=0.9;b=3;b=4"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;a=1;a=2;q=0.9;b=3;b=4", mr); assertTextEquals("text/json;a=1;a=2", mr.getMediaType()); assertObjectEquals("{a:['1','2']}", mr.getMediaType().getParameters()); @@ -72,7 +72,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{b:['3','4']}", mr.getExtensions()); accept = Accept.forString("text/json;a=1"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;a=1", mr); assertTextEquals("text/json;a=1", mr.getMediaType()); assertObjectEquals("{a:['1']}", mr.getMediaType().getParameters()); @@ -80,7 +80,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString("text/json;a=1;"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;a=1", mr); assertTextEquals("text/json;a=1", mr.getMediaType()); assertObjectEquals("{a:['1']}", mr.getMediaType().getParameters()); @@ -88,7 +88,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString("text/json;q=0.9"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;q=0.9", mr); assertTextEquals("text/json", mr.getMediaType()); assertObjectEquals("{}", mr.getMediaType().getParameters()); @@ -96,7 +96,7 @@ public class AcceptExtensionsTest { assertObjectEquals("{}", mr.getExtensions()); accept = Accept.forString("text/json;q=0.9;"); - mr = accept.getMediaRanges().get(0); + mr = accept.asRanges().get(0); assertTextEquals("text/json;q=0.9", mr); assertTextEquals("text/json", mr.getMediaType()); assertObjectEquals("{}", mr.getMediaType().getParameters()); http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/BeanContext.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/BeanContext.java b/juneau-core/src/main/java/org/apache/juneau/BeanContext.java index c5df1d1..33c1165 100644 --- a/juneau-core/src/main/java/org/apache/juneau/BeanContext.java +++ b/juneau-core/src/main/java/org/apache/juneau/BeanContext.java @@ -942,7 +942,7 @@ public class BeanContext extends Context { * If <jk>null</jk>, the system default locale is assumed. * @param timeZone The bean session timezone. * Typically used by time-sensitive {@link PojoSwap PojoSwaps} to provide timezone-specific output. - * If <jk>null</jk> the system default timezone is assumed on {@link Date} objects, or the + * If <jk>null</jk> the system default timezone is assumed on {@link java.util.Date} objects, or the * locale specified on {@link Calendar} objects are used. * @param mediaType The session media type (e.g. <js>"application/json"</js>). * @return A new session object. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Accept.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Accept.java b/juneau-core/src/main/java/org/apache/juneau/http/Accept.java index 5fabc73..48aa91a 100644 --- a/juneau-core/src/main/java/org/apache/juneau/http/Accept.java +++ b/juneau-core/src/main/java/org/apache/juneau/http/Accept.java @@ -12,24 +12,29 @@ // *************************************************************************************************************************** package org.apache.juneau.http; +import static org.apache.juneau.http.Constants.*; + import java.util.*; -import java.util.concurrent.*; import org.apache.juneau.internal.*; /** - * Represents a parsed <code>Accept:</code> HTTP header. + * Represents a parsed <l>Accept</l> HTTP request header. * <p> - * The formal RFC2616 header field definition is as follows: + * Content-Types that are acceptable for the response. + * + * <h6 class='figure'>Example</h6> * <p class='bcode'> - * 14.1 Accept + * Accept: text/plain + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> * - * The Accept request-header field can be used to specify certain media - * types which are acceptable for the response. Accept headers can be - * used to indicate that the request is specifically limited to a small - * set of desired types, as in the case of a request for an in-line - * image. + * The Accept request-header field can be used to specify certain media types which are acceptable for the response. + * Accept headers can be used to indicate that the request is specifically limited to a small set of desired types, as + * in the case of a request for an in-line image. * + * <p class='bcode'> * Accept = "Accept" ": * #( media-range [ accept-params ] ) * @@ -39,122 +44,111 @@ import org.apache.juneau.internal.*; * ) *( ";" parameter ) * accept-params = ";" "q" "=" qvalue *( accept-extension ) * accept-extension = ";" token [ "=" ( token | quoted-string ) ] - * - * The asterisk "*" character is used to group media types into ranges, - * with "* /*" indicating all media types and "type/*" indicating all - * subtypes of that type. The media-range MAY include media type - * parameters that are applicable to that range. - * - * Each media-range MAY be followed by one or more accept-params, - * beginning with the "q" parameter for indicating a relative quality - * factor. The first "q" parameter (if any) separates the media-range - * parameter(s) from the accept-params. Quality factors allow the user - * or user agent to indicate the relative degree of preference for that - * media-range, using the qvalue scale from 0 to 1 (section 3.9). The - * default value is q=1. - * - * Note: Use of the "q" parameter name to separate media type - * parameters from Accept extension parameters is due to historical - * practice. Although this prevents any media type parameter named - * "q" from being used with a media range, such an event is believed - * to be unlikely given the lack of any "q" parameters in the IANA - * media type registry and the rare usage of any media type - * parameters in Accept. Future media types are discouraged from - * registering any parameter named "q". - * - * The example - * - * Accept: audio/*; q=0.2, audio/basic - * - * SHOULD be interpreted as "I prefer audio/basic, but send me any audio - * type if it is the best available after an 80% mark-down in quality." - * - * If no Accept header field is present, then it is assumed that the - * client accepts all media types. If an Accept header field is present, - * and if the server cannot send a response which is acceptable - * according to the combined Accept field value, then the server SHOULD - * send a 406 (not acceptable) response. - * - * A more elaborate example is - * - * Accept: text/plain; q=0.5, text/html, - * text/x-dvi; q=0.8, text/x-c - * - * Verbally, this would be interpreted as "text/html and text/x-c are - * the preferred media types, but if they do not exist, then send the - * text/x-dvi entity, and if that does not exist, send the text/plain - * entity." - * - * Media ranges can be overridden by more specific media ranges or - * specific media types. If more than one media range applies to a given - * type, the most specific reference has precedence. For example, - * - * Accept: text/ *, text/html, text/html;level=1, * /* - * - * have the following precedence: - * - * 1) text/html;level=1 - * 2) text/html - * 3) text/* - * 4) * /* - * - * The media type quality factor associated with a given type is - * determined by finding the media range with the highest precedence - * which matches that type. For example, - * - * Accept: text/*;q=0.3, text/html;q=0.7, text/html;level=1, - * text/html;level=2;q=0.4, * /*;q=0.5 - * - * would cause the following values to be associated: - * - * text/html;level=1 = 1 - * text/html = 0.7 - * text/plain = 0.3 - * image/jpeg = 0.5 - * text/html;level=2 = 0.4 - * text/html;level=3 = 0.7 - * - * Note: A user agent might be provided with a default set of quality - * values for certain media ranges. However, unless the user agent is - * a closed system which cannot interact with other rendering agents, - * this default set ought to be configurable by the user. * </p> + * <p> + * The asterisk "*" character is used to group media types into ranges, with "* /*" indicating all media types and + * "type/*" indicating all subtypes of that type. + * The media-range MAY include media type parameters that are applicable to that range. + * <p> + * Each media-range MAY be followed by one or more accept-params, beginning with the "q" parameter for indicating a + * relative quality factor. + * The first "q" parameter (if any) separates the media-range parameter(s) from the accept-params. + * Quality factors allow the user or user agent to indicate the relative degree of preference for that media-range, + * using the qvalue scale from 0 to 1 (section 3.9). + * The default value is q=1. + * <p> + * Note: Use of the "q" parameter name to separate media type parameters from Accept extension parameters is due to + * historical practice. + * Although this prevents any media type parameter named "q" from being used with a media range, such an event is + * believed to be unlikely given the lack of any "q" parameters in the IANA + * media type registry and the rare usage of any media type parameters in Accept. + * Future media types are discouraged from registering any parameter named "q". + * <p> + * The example + * <p class='bcode'> + * Accept: audio/*; q=0.2, audio/basic + * </p> + * <p> + * SHOULD be interpreted as "I prefer audio/basic, but send me any audio type if it is the best available after an 80% + * mark-down in quality." + * <p> + * If no Accept header field is present, then it is assumed that the client accepts all media types. + * <p> + * If an Accept header field is present, and if the server cannot send a response which is acceptable according to the + * combined Accept field value, then the server SHOULD send a 406 (not acceptable) response. + * <p> + * A more elaborate example is + * <p class='bcode'> + * Accept: text/plain; q=0.5, text/html, + * text/x-dvi; q=0.8, text/x-c + * </p> + * <p> + * Verbally, this would be interpreted as "text/html and text/x-c are the preferred media types, but if they do not + * exist, then send the + * text/x-dvi entity, and if that does not exist, send the text/plain entity." + * <p> + * Media ranges can be overridden by more specific media ranges or specific media types. + * If more than one media range applies to a given type, the most specific reference has precedence. + * For example, + * <p class='bcode'> + * Accept: text/ *, text/html, text/html;level=1, * /* + * </p> + * <p> + * have the following precedence: + * <ol> + * <li>text/html;level=1 + * <li>text/html + * <li>text/* + * <li>* /* + * </ol> + * <p> + * The media type quality factor associated with a given type is determined by finding the media range with the highest + * precedence which matches that type. + * For example, + * <p class='bcode'> + * Accept: text/*;q=0.3, text/html;q=0.7, text/html;level=1, + * text/html;level=2;q=0.4, * /*;q=0.5 + * </p> + * <p> + * would cause the following values to be associated: + * <p class='bcode'> + * text/html;level=1 = 1 + * text/html = 0.7 + * text/plain = 0.3 + * image/jpeg = 0.5 + * text/html;level=2 = 0.4 + * text/html;level=3 = 0.7 + * </p> + * <p> + * Note: A user agent might be provided with a default set of quality values for certain media ranges. + * However, unless the user agent is a closed system which cannot interact with other rendering agents, this default + * set ought to be configurable by the user. */ public final class Accept { - private static final boolean nocache = Boolean.getBoolean("juneau.http.Accept.nocache"); - private static final ConcurrentHashMap<String,Accept> cache = new ConcurrentHashMap<String,Accept>(); - - private final MediaTypeRange[] mediaRanges; - private final List<MediaTypeRange> mediaRangesList; + private static final Cache<String,Accept> cache = new Cache<String,Accept>(NOCACHE, CACHE_MAX_SIZE); /** * Returns a parsed <code>Accept</code> header. * - * @param s The <code>Accept</code> header string. + * @param value The <code>Accept</code> header string. * @return The parsed <code>Accept</code> header, or <jk>null</jk> if the string was null. */ - public static Accept forString(String s) { - if (s == null) + public static Accept forString(String value) { + if (value == null) return null; - - // Prevent OOM in case of DDOS - if (cache.size() > 1000) - cache.clear(); - - while (true) { - Accept a = cache.get(s); - if (a != null) - return a; - a = new Accept(s); - if (nocache) - return a; - cache.putIfAbsent(s, a); - } + Accept a = cache.get(value); + if (a == null) + a = cache.put(value, new Accept(value)); + return a; } - private Accept(String raw) { - this.mediaRanges = MediaTypeRange.parse(raw); + + private final MediaTypeRange[] mediaRanges; + private final List<MediaTypeRange> mediaRangesList; + + private Accept(String value) { + this.mediaRanges = MediaTypeRange.parse(value); this.mediaRangesList = Collections.unmodifiableList(Arrays.asList(mediaRanges)); } @@ -165,7 +159,7 @@ public final class Accept { * * @return An unmodifiable list of media ranges. */ - public List<MediaTypeRange> getMediaRanges() { + public List<MediaTypeRange> asRanges() { return mediaRangesList; } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/AcceptCharset.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/AcceptCharset.java b/juneau-core/src/main/java/org/apache/juneau/http/AcceptCharset.java new file mode 100644 index 0000000..3792104 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/AcceptCharset.java @@ -0,0 +1,82 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +import static org.apache.juneau.http.Constants.*; + +import org.apache.juneau.internal.*; + +/** + * Represents a parsed <l>Accept-Charset</l> HTTP request header. + * <p> + * Character sets that are acceptable. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Accept-Charset: utf-8 + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Accept-Charset request-header field can be used to indicate what character sets are acceptable for the response. + * <p> + * This field allows clients capable of understanding more comprehensive or special- purpose character sets to signal + * that capability to a server which is capable of representing documents in those character sets. + * <p class='bcode'> + * Accept-Charset = "Accept-Charset" ":" + * 1#( ( charset | "*" )[ ";" "q" "=" qvalue ] ) + * </p> + * <p> + * Character set values are described in section 3.4. Each charset MAY be given an associated quality value which + * represents the user's preference for that charset. + * The default value is q=1. + * An example is... + * <p class='bcode'> + * Accept-Charset: iso-8859-5, unicode-1-1;q=0.8 + * </p> + * <p> + * The special value "*", if present in the Accept-Charset field, matches every character set (including ISO-8859-1) + * which is not mentioned elsewhere in the Accept-Charset field. + * <p> + * If no "*" is present in an Accept-Charset field, then all character sets not explicitly mentioned get a quality + * value of 0, except for ISO-8859-1, which gets a quality value of 1 if not explicitly mentioned. + * <p> + * If no Accept-Charset header is present, the default is that any character set is acceptable. + * <p> + * If an Accept-Charset header is present, and if the server cannot send a response which is acceptable according to + * the Accept-Charset header, then the server SHOULD send an error response with the 406 (not acceptable) status code, + * though the sending of an unacceptable response is also allowed. + */ +public final class AcceptCharset extends HeaderRangeArray { + + private static final Cache<String,AcceptCharset> cache = new Cache<String,AcceptCharset>(NOCACHE, CACHE_MAX_SIZE); + + /** + * Returns a parsed <code>Accept-Charset</code> header. + * + * @param value The <code>Accept-Charset</code> header string. + * @return The parsed <code>Accept-Charset</code> header, or <jk>null</jk> if the string was null. + */ + public static AcceptCharset forString(String value) { + if (value == null) + return null; + AcceptCharset a = cache.get(value); + if (a == null) + a = cache.put(value, new AcceptCharset(value)); + return a; + } + + private AcceptCharset(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/AcceptEncoding.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/AcceptEncoding.java b/juneau-core/src/main/java/org/apache/juneau/http/AcceptEncoding.java index 8d83401..1502e57 100644 --- a/juneau-core/src/main/java/org/apache/juneau/http/AcceptEncoding.java +++ b/juneau-core/src/main/java/org/apache/juneau/http/AcceptEncoding.java @@ -12,142 +12,91 @@ // *************************************************************************************************************************** package org.apache.juneau.http; -import java.util.*; -import java.util.concurrent.*; +import static org.apache.juneau.http.Constants.*; import org.apache.juneau.internal.*; /** - * Represents a parsed <code>Accept-Encoding:</code> HTTP header. + * Represents a parsed <l>Accept-Encoding</l> HTTP request header. * <p> - * The formal RFC2616 header field definition is as follows: - * <p class='bcode'> - * The Accept-Encoding request-header field is similar to Accept, but restricts - * the content-codings (section 3.5) that are acceptable in the response. - * - * Accept-Encoding = "Accept-Encoding" ":" - * 1#( codings [ ";" "q" "=" qvalue ] ) - * codings = ( content-coding | "*" ) - * - * Examples of its use are: - * - * Accept-Encoding: compress, gzip - * Accept-Encoding: - * Accept-Encoding: * - * Accept-Encoding: compress;q=0.5, gzip;q=1.0 - * Accept-Encoding: gzip;q=1.0, identity; q=0.5, *;q=0 - * - * A server tests whether a content-coding is acceptable, according to an - * Accept-Encoding field, using these rules: + * List of acceptable encodings. * - * 1. If the content-coding is one of the content-codings listed in - * the Accept-Encoding field, then it is acceptable, unless it is - * accompanied by a qvalue of 0. (As defined in section 3.9, a - * qvalue of 0 means "not acceptable.") - * 2. The special "*" symbol in an Accept-Encoding field matches any - * available content-coding not explicitly listed in the header - * field. - * 3. If multiple content-codings are acceptable, then the acceptable - * content-coding with the highest non-zero qvalue is preferred. - * 4. The "identity" content-coding is always acceptable, unless - * specifically refused because the Accept-Encoding field includes - * "identity;q=0", or because the field includes "*;q=0" and does - * not explicitly include the "identity" content-coding. If the - * Accept-Encoding field-value is empty, then only the "identity" - * encoding is acceptable. + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Accept-Encoding: gzip, deflate + * </p> * - * If an Accept-Encoding field is present in a request, and if the server cannot - * send a response which is acceptable according to the Accept-Encoding header, - * then the server SHOULD send an error response with the 406 (Not Acceptable) status code. + * <h6 class='topic'>RFC2616 Specification</h6> * - * If no Accept-Encoding field is present in a request, the server MAY assume - * that the client will accept any content coding. In this case, if "identity" - * is one of the available content-codings, then the server SHOULD use the "identity" - * content-coding, unless it has additional information that a different content-coding - * is meaningful to the client. + * The Accept-Encoding request-header field is similar to Accept, but restricts the content-codings (section 3.5) that are acceptable in the response. * - * Note: If the request does not include an Accept-Encoding field, - * and if the "identity" content-coding is unavailable, then - * content-codings commonly understood by HTTP/1.0 clients (i.e., - * "gzip" and "compress") are preferred; some older clients - * improperly display messages sent with other content-codings. The - * server might also make this decision based on information about - * the particular user-agent or client. - * Note: Most HTTP/1.0 applications do not recognize or obey qvalues - * associated with content-codings. This means that qvalues will not - * work and are not permitted with x-gzip or x-compress. + * <p class='bcode'> + * Accept-Encoding = "Accept-Encoding" ":" + * 1#( codings [ ";" "q" "=" qvalue ] ) + * codings = ( content-coding | "*" ) * </p> + * <p> + * Examples of its use are: + * <p class='bcode'> + * Accept-Encoding: compress, gzip + * Accept-Encoding: + * Accept-Encoding: * + * Accept-Encoding: compress;q=0.5, gzip;q=1.0 + * Accept-Encoding: gzip;q=1.0, identity; q=0.5, *;q=0 + * </p> + * <p> + * A server tests whether a content-coding is acceptable, according to an Accept-Encoding field, using these rules: + * <ol> + * <li>If the content-coding is one of the content-codings listed in the Accept-Encoding field, then it is + * acceptable, unless it is accompanied by a qvalue of 0. + * (As defined in section 3.9, a qvalue of 0 means "not acceptable.") + * <li>The special "*" symbol in an Accept-Encoding field matches any available content-coding not explicitly listed + * in the header field. + * <li>If multiple content-codings are acceptable, then the acceptable content-coding with the highest non-zero + * qvalue is preferred. + * <li>The "identity" content-coding is always acceptable, unless specifically refused because the Accept-Encoding + * field includes "identity;q=0", or because the field includes "*;q=0" and does not explicitly include the + * "identity" content-coding. + * If the Accept-Encoding field-value is empty, then only the "identity" encoding is acceptable. + * </ol> + * <p> + * If an Accept-Encoding field is present in a request, and if the server cannot send a response which is acceptable + * according to the Accept-Encoding header, then the server SHOULD send an error response with the 406 (Not Acceptable) + * status code. + * <p> + * If no Accept-Encoding field is present in a request, the server MAY assume that the client will accept any content + * coding. + * In this case, if "identity" is one of the available content-codings, then the server SHOULD use the "identity" + * content-coding, unless it has additional information that a different content-coding is meaningful to the client. + * <p> + * Note: If the request does not include an Accept-Encoding field, and if the "identity" content-coding is unavailable, + * then content-codings commonly understood by HTTP/1.0 clients (i.e.,"gzip" and "compress") are preferred; some older + * clients improperly display messages sent with other content-codings. + * The server might also make this decision based on information about the particular user-agent or client. + * <p> + * Note: Most HTTP/1.0 applications do not recognize or obey qvalues associated with content-codings. + * This means that qvalues will not work and are not permitted with x-gzip or x-compress. */ -public final class AcceptEncoding { - - private static final boolean nocache = Boolean.getBoolean("juneau.http.AcceptEncoding.nocache"); - private static final ConcurrentHashMap<String,AcceptEncoding> cache = new ConcurrentHashMap<String,AcceptEncoding>(); +public final class AcceptEncoding extends HeaderRangeArray { - private final TypeRange[] typeRanges; - private final List<TypeRange> typeRangesList; + private static final Cache<String,AcceptEncoding> cache = new Cache<String,AcceptEncoding>(NOCACHE, CACHE_MAX_SIZE); /** * Returns a parsed <code>Accept-Encoding</code> header. * - * @param s The <code>Accept-Encoding</code> header string. + * @param value The <code>Accept-Encoding</code> header string. * @return The parsed <code>Accept-Encoding</code> header, or <jk>null</jk> if the string was null. */ - public static AcceptEncoding forString(String s) { - if (s == null) + public static AcceptEncoding forString(String value) { + if (value == null) return null; - - // Prevent OOM in case of DDOS - if (cache.size() > 1000) - cache.clear(); - - while (true) { - AcceptEncoding a = cache.get(s); - if (a != null) - return a; - a = new AcceptEncoding(s); - if (nocache) - return a; - cache.putIfAbsent(s, a); - } - } - - private AcceptEncoding(String raw) { - this.typeRanges = TypeRange.parse(raw); - this.typeRangesList = Collections.unmodifiableList(Arrays.asList(typeRanges)); - } - - /** - * Returns the list of the types ranges that make up this header. - * <p> - * The types ranges in the list are sorted by their q-value in descending order. - * - * @return An unmodifiable list of type ranges. - */ - public List<TypeRange> getTypeRanges() { - return typeRangesList; - } - - /** - * Given a list of content codings, returns the best match for this <code>Accept-Encoding</code> header. - * <p> - * - * @param contentCodings The codings to match against. - * @return The index into the array of the best match, or <code>-1</code> if no suitable matches could be found. - */ - public int findMatch(String[] contentCodings) { - - // Type ranges are ordered by 'q'. - // So we only need to search until we've found a match. - for (TypeRange mr : typeRanges) - for (int i = 0; i < contentCodings.length; i++) - if (mr.matches(contentCodings[i])) - return i; - - return -1; + AcceptEncoding a = cache.get(value); + if (a == null) + a = cache.put(value, new AcceptEncoding(value)); + return a; } - @Override /* Object */ - public String toString() { - return StringUtils.join(typeRanges, ','); + private AcceptEncoding(String value) { + super(value); } } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/AcceptLanguage.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/AcceptLanguage.java b/juneau-core/src/main/java/org/apache/juneau/http/AcceptLanguage.java new file mode 100644 index 0000000..654abf7 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/AcceptLanguage.java @@ -0,0 +1,110 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +import static org.apache.juneau.http.Constants.*; + +import org.apache.juneau.internal.*; + +/** + * Represents a parsed <l>Accept-Language</l> HTTP request header. + * <p> + * List of acceptable human languages for response. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Accept-Language: en-US + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Accept-Language request-header field is similar to Accept, but restricts the set of natural languages that are + * preferred as a response to the request. + * Language tags are defined in section 3.10. + * + * <p class='bcode'> + * Accept-Language = "Accept-Language" ":" + * 1#( language-range [ ";" "q" "=" qvalue ] ) + * language-range = ( ( 1*8ALPHA *( "-" 1*8ALPHA ) ) | "*" ) + * </p> + * <p> + * Each language-range MAY be given an associated quality value which represents an estimate of the user's preference + * for the languages specified by that range. + * The quality value defaults to "q=1". + * For example... + * <p class='bcode'> + * Accept-Language: da, en-gb;q=0.8, en;q=0.7 + * </p> + * <p> + * ...would mean: "I prefer Danish, but will accept British English and other types of English." + * <p> + * A language-range matches a language-tag if it exactly equals the tag, or if it exactly equals a prefix of the tag + * such that the first tag character following the prefix is "-". + * <p> + * The special range "*", if present in the Accept-Language field, matches every tag not matched by any other range + * present in the Accept-Language field. + * <p> + * Note: This use of a prefix matching rule does not imply that language tags are assigned to languages in such a way + * that it is always true that if a user understands a language with a certain + * tag, then this user will also understand all languages with tags for which this tag is a prefix. + * The prefix rule simply allows the use of prefix tags if this is the case. + * <p> + * The language quality factor assigned to a language-tag by the Accept-Language field is the quality value of the + * longest language- range in the field that matches the language-tag. + * <p> + * If no language- range in the field matches the tag, the language quality factor assigned is 0. + * <p> + * If no Accept-Language header is present in the request, the server SHOULD assume that all languages are equally + * acceptable. + * <p> + * If an Accept-Language header is present, then all languages which are assigned a quality factor greater than 0 are + * acceptable. + * <p> + * It might be contrary to the privacy expectations of the user to send an Accept-Language header with the complete + * linguistic preferences of the user in every request. + * For a discussion of this issue, see section 15.1.4. + * <p> + * As intelligibility is highly dependent on the individual user, it is recommended that client applications make the + * choice of linguistic preference available to the user. + * If the choice is not made available, then the Accept-Language header field MUST NOT be given in the request. + * <p> + * Note: When making the choice of linguistic preference available to the user, we remind implementors of the fact that + * users are not familiar with the details of language matching as described above, and should provide appropriate + * guidance. + * As an example, users might assume that on selecting "en-gb", they will be served any kind of English document if + * British English is not available. + * A user agent might suggest in such a case to add "en" to get the best matching behavior. + */ +public final class AcceptLanguage extends HeaderRangeArray { + + private static final Cache<String,AcceptLanguage> cache = new Cache<String,AcceptLanguage>(NOCACHE, CACHE_MAX_SIZE); + + /** + * Returns a parsed <code>Accept-Language</code> header. + * + * @param value The <code>Accept-Language</code> header string. + * @return The parsed <code>Accept-Language</code> header, or <jk>null</jk> if the string was null. + */ + public static AcceptLanguage forString(String value) { + if (value == null) + return null; + AcceptLanguage a = cache.get(value); + if (a == null) + a = cache.put(value, new AcceptLanguage(value)); + return a; + } + + private AcceptLanguage(String raw) { + super(raw); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/AcceptRanges.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/AcceptRanges.java b/juneau-core/src/main/java/org/apache/juneau/http/AcceptRanges.java new file mode 100644 index 0000000..eeb4aea --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/AcceptRanges.java @@ -0,0 +1,69 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Accept-Range</l> HTTP response header. + * <p> + * What partial content range types this server supports via byte serving. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Accept-Ranges: bytes + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Accept-Ranges response-header field allows the server to indicate its acceptance of range requests for a + * resource: + * <p class='bcode'> + * Accept-Ranges = "Accept-Ranges" ":" acceptable-ranges + * acceptable-ranges = 1#range-unit | "none" + * </p> + * <p> + * Origin servers that accept byte-range requests MAY send... + * <p class='bcode'> + * Accept-Ranges: bytes + * </p> + * <p> + * ...but are not required to do so. + * <p> + * Clients MAY generate byte-range requests without having received this header for the resource involved. + * <p> + * Range units are defined in section 3.12. + * <p> + * Servers that do not accept any kind of range request for a resource MAY send... + * <p class='bcode'> + * Accept-Ranges: none + * </p> + * <p> + * ...to advise the client not to attempt a range request. + */ +public final class AcceptRanges extends HeaderString { + + /** + * Returns a parsed <code>Accept-Ranges</code> header. + * + * @param value The <code>Accept-Ranges</code> header string. + * @return The parsed <code>Accept-Ranges</code> header, or <jk>null</jk> if the string was null. + */ + public static AcceptRanges forString(String value) { + if (value == null) + return null; + return new AcceptRanges(value); + } + + private AcceptRanges(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Age.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Age.java b/juneau-core/src/main/java/org/apache/juneau/http/Age.java new file mode 100644 index 0000000..1e4aec5 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/Age.java @@ -0,0 +1,64 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Age</l> HTTP response header. + * <p> + * The age the object has been in a proxy cache in seconds. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Age: 12 + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Age response-header field conveys the sender's estimate of the amount of time since the response (or its + * revalidation) was generated at the origin server. + * A cached response is "fresh" if its age does not exceed its freshness lifetime. + * Age values are calculated as specified in section 13.2.3. + * + * <p class='bcode'> + * Age = "Age" ":" age-value + * age-value = delta-seconds + * </p> + * <p> + * Age values are non-negative decimal integers, representing time in seconds. + * <p> + * If a cache receives a value larger than the largest positive integer it can represent, or if any of its age + * calculations overflows, it MUST transmit an Age header with a value of 2147483648 (2^31). + * <p> + * An HTTP/1.1 server that includes a cache MUST include an Age header field in every response generated from its own + * cache. + * <p> + * Caches SHOULD use an arithmetic type of at least 31 bits of range. + */ +public final class Age extends HeaderInteger { + + /** + * Returns a parsed <code>Age</code> header. + * + * @param value The <code>Age</code> header string. + * @return The parsed <code>Age</code> header, or <jk>null</jk> if the string was null. + */ + public static Age forString(String value) { + if (value == null) + return null; + return new Age(value); + } + + private Age(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Allow.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Allow.java b/juneau-core/src/main/java/org/apache/juneau/http/Allow.java new file mode 100644 index 0000000..67dbc80 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/Allow.java @@ -0,0 +1,72 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Allow</l> HTTP response header. + * <p> + * Valid methods for a specified resource. To be used for a 405 Method not allowed. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Allow: GET, HEAD + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Allow entity-header field lists the set of methods supported by the resource identified by the Request-URI. + * The purpose of this field is strictly to inform the recipient of valid methods associated with the resource. + * An Allow header field MUST be present in a 405 (Method Not Allowed) response. + * + * <p class='bcode'> + * Allow = "Allow" ":" #Method + * </p> + * <p> + * Example of use: + * <p class='bcode'> + * Allow: GET, HEAD, PUT + * </p> + * <p> + * This field cannot prevent a client from trying other methods. + * However, the indications given by the Allow header field value SHOULD be followed. + * <p> + * The actual set of allowed methods is defined by the origin server at the time of each request. + * <p> + * The Allow header field MAY be provided with a PUT request to recommend the methods to be supported by the new or + * modified resource. + * <p> + * The server is not required to support these methods and SHOULD include an Allow header in the response giving the + * actual supported methods. + * <p> + * A proxy MUST NOT modify the Allow header field even if it does not understand all the methods specified, since the + * user agent might + * have other means of communicating with the origin server. + */ +public final class Allow extends HeaderStringArray { + + /** + * Returns a parsed <code>Allow</code> header. + * + * @param value The <code>Allow</code> header string. + * @return The parsed <code>Allow</code> header, or <jk>null</jk> if the string was null. + */ + public static Allow forString(String value) { + if (value == null) + return null; + return new Allow(value); + } + + private Allow(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Authorization.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Authorization.java b/juneau-core/src/main/java/org/apache/juneau/http/Authorization.java new file mode 100644 index 0000000..530bd4d --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/Authorization.java @@ -0,0 +1,78 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Authorization</l> HTTP request header. + * <p> + * Authentication credentials for HTTP authentication. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * A user agent that wishes to authenticate itself with a server--usually, but not necessarily, after receiving a 401 + * response--does so by including an Authorization request-header field with the request. + * <p> + * The Authorization field value consists of credentials containing the authentication information of the user agent for + * the realm of the resource being requested. + * + * <p class='bcode'> + * Authorization = "Authorization" ":" credentials + * </p> + * <p> + * HTTP access authentication is described in "HTTP Authentication: Basic and Digest Access Authentication". + * <p> + * If a request is authenticated and a realm specified, the same credentials SHOULD be valid for all other requests + * within this realm (assuming that the authentication scheme itself does not require otherwise, such as credentials + * that vary according to a challenge value or using synchronized clocks). + * <p> + * When a shared cache (see section 13.7) receives a request containing an Authorization field, it MUST NOT return the + * corresponding response as a reply to any other request, unless one of the following specific exceptions holds: + * <ol> + * <li>If the response includes the "s-maxage" cache-control directive, the cache MAY use that response in replying + * to a subsequent request. + * But (if the specified maximum age has passed) a proxy cache MUST first revalidate it with the origin + * server, using the request-headers from the new request to allow the origin server to authenticate the new + * request. + * (This is the defined behavior for s-maxage.) + * If the response includes "s-maxage=0", the proxy MUST always revalidate it before re-using it. + * <li>If the response includes the "must-revalidate" cache-control directive, the cache MAY use that response in + * replying to a subsequent request. + * But if the response is stale, all caches MUST first revalidate it with the origin server, using the + * request-headers from the new request to allow the origin server to authenticate the new request. + * <li>If the response includes the "public" cache-control directive, it MAY be returned in reply to any subsequent + * request. + * </ol> + */ +public final class Authorization extends HeaderString { + + /** + * Returns a parsed <code>Authorization</code> header. + * + * @param value The <code>Authorization</code> header string. + * @return The parsed <code>Authorization</code> header, or <jk>null</jk> if the string was null. + */ + public static Authorization forString(String value) { + if (value == null) + return null; + return new Authorization(value); + } + + private Authorization(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/CacheControl.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/CacheControl.java b/juneau-core/src/main/java/org/apache/juneau/http/CacheControl.java new file mode 100644 index 0000000..27a67a2 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/CacheControl.java @@ -0,0 +1,102 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Cache-Control</l> HTTP request header. + * <p> + * Used to specify directives that must be obeyed by all caching mechanisms along the request-response chain. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Cache-Control: no-cache + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Cache-Control general-header field is used to specify directives that MUST be obeyed by all caching mechanisms + * along the request/response chain. + * The directives specify behavior intended to prevent caches from adversely interfering with the request or response. + * These directives typically override the default caching algorithms. + * Cache directives are unidirectional in that the presence of a directive in a request does not imply that the same + * directive is to be given in the response. + * <p> + * Note that HTTP/1.0 caches might not implement Cache-Control and might only implement Pragma: no-cache (see section + * 14.32). + * <p> + * Cache directives MUST be passed through by a proxy or gateway application, regardless of their significance to that + * application, since the directives might be applicable to all recipients along the request/response chain. + * It is not possible to specify a cache- directive for a specific cache. + * + * <p class='bcode'> + * Cache-Control = "Cache-Control" ":" 1#cache-directive + * cache-directive = cache-request-directive + * | cache-response-directive + * cache-request-directive = + * "no-cache" ; Section 14.9.1 + * | "no-store" ; Section 14.9.2 + * | "max-age" "=" delta-seconds ; Section 14.9.3, 14.9.4 + * | "max-stale" [ "=" delta-seconds ] ; Section 14.9.3 + * | "min-fresh" "=" delta-seconds ; Section 14.9.3 + * | "no-transform" ; Section 14.9.5 + * | "only-if-cached" ; Section 14.9.4 + * | cache-extension ; Section 14.9.6 + * cache-response-directive = + * "public" ; Section 14.9.1 + * | "private" [ "=" <"> 1#field-name <"> ] ; Section 14.9.1 + * | "no-cache" [ "=" <"> 1#field-name <"> ]; Section 14.9.1 + * | "no-store" ; Section 14.9.2 + * | "no-transform" ; Section 14.9.5 + * | "must-revalidate" ; Section 14.9.4 + * | "proxy-revalidate" ; Section 14.9.4 + * | "max-age" "=" delta-seconds ; Section 14.9.3 + * | "s-maxage" "=" delta-seconds ; Section 14.9.3 + * | cache-extension ; Section 14.9.6 + * cache-extension = token [ "=" ( token | quoted-string ) ] + * </p> + * <p> + * When a directive appears without any 1#field-name parameter, the directive applies to the entire request or response. + * When such a directive appears with a 1#field-name parameter, it applies only to the named field or fields, and not + * to the rest of the request or response. This mechanism supports extensibility; implementations of future versions + * of the HTTP protocol might apply these directives to header fields not defined in HTTP/1.1. + * <p> + * The cache-control directives can be broken down into these general categories: + * <ul> + * <li>Restrictions on what are cacheable; these may only be imposed by the origin server. + * <li>Restrictions on what may be stored by a cache; these may be imposed by either the origin server or the user + * agent. + * <li>Modifications of the basic expiration mechanism; these may be imposed by either the origin server or the + * user agent. + * <li>Controls over cache revalidation and reload; these may only be imposed by a user agent. + * <li>Control over transformation of entities. + * <li>Extensions to the caching system. + * </ul> + */ +public final class CacheControl extends HeaderString { + + /** + * Returns a parsed <code>Cache-Control</code> header. + * + * @param value The <code>Cache-Control</code> header string. + * @return The parsed <code>Cache-Control</code> header, or <jk>null</jk> if the string was null. + */ + public static CacheControl forString(String value) { + if (value == null) + return null; + return new CacheControl(value); + } + + private CacheControl(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Connection.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Connection.java b/juneau-core/src/main/java/org/apache/juneau/http/Connection.java new file mode 100644 index 0000000..2eaec3a --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/Connection.java @@ -0,0 +1,106 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Connection</l> HTTP request header. + * <p> + * Control options for the current connection and list of hop-by-hop request fields. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Connection: keep-alive + * Connection: Upgrade + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Connection general-header field allows the sender to specify options that are desired for that particular + * connection and MUST NOT be communicated by proxies over further connections. + * <p> + * The Connection header has the following grammar: + * <p class='bcode'> + * Connection = "Connection" ":" 1#(connection-token) + * connection-token = token + * </p> + * <p> + * HTTP/1.1 proxies MUST parse the Connection header field before a message is forwarded and, for each connection-token + * in this field, remove any header field(s) from the message with the same name as the connection-token. + * Connection options are signaled by the presence of a connection-token in the Connection header field, not by any + * corresponding additional header field(s), since the additional header field may not be sent if there are no + * parameters associated with that connection option. + * <p> + * Message headers listed in the Connection header MUST NOT include end-to-end headers, such as Cache-Control. + * <p> + * HTTP/1.1 defines the "close" connection option for the sender to signal that the connection will be closed after + * completion of the response. + * For example... + * <p class='bcode'> + * Connection: close + * </p> + * <p> + * ...in either the request or the response header fields indicates that the connection SHOULD NOT be considered + * `persistent' (section 8.1) after the current request/response is complete. + * <p> + * HTTP/1.1 applications that do not support persistent connections MUST include the "close" connection option in + * every message. + * <p> + * A system receiving an HTTP/1.0 (or lower-version) message that includes a Connection header MUST, for each + * connection-token in this field, remove and ignore any header field(s) from the message with the same name as the + * connection-token. + * This protects against mistaken forwarding of such header fields by pre-HTTP/1.1 proxies. + * See section 19.6.2. + */ +public final class Connection extends HeaderString { + + /** + * Returns a parsed <code>Connection</code> header. + * + * @param value The <code>Connection</code> header string. + * @return The parsed <code>Connection</code> header, or <jk>null</jk> if the string was null. + */ + public static Connection forString(String value) { + if (value == null) + return null; + return new Connection(value); + } + + + private Connection(String value) { + super(value); + } + + /** + * Returns <jk>true</jk> if the header value is <code>close</code>. + * @return <jk>true</jk> if the header value is <code>close</code>. + */ + public boolean isClose() { + return eqIC("close"); + } + + /** + * Returns <jk>true</jk> if the header value is <code>keep-alive</code>. + * @return <jk>true</jk> if the header value is <code>keep-alive</code>. + */ + public boolean isKeepAlive() { + return eqIC("keep-alive"); + } + + /** + * Returns <jk>true</jk> if the header value is <code>upgrade</code>. + * @return <jk>true</jk> if the header value is <code>upgrade</code>. + */ + public boolean isUpgrade() { + return eqIC("upgrade"); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/Constants.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/Constants.java b/juneau-core/src/main/java/org/apache/juneau/http/Constants.java new file mode 100644 index 0000000..7f31635 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/Constants.java @@ -0,0 +1,21 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Constants used by classes in this package. + */ +public class Constants { + static boolean NOCACHE = Boolean.getBoolean("juneau.http.cache.disable"); + static int CACHE_MAX_SIZE = Integer.getInteger("juneau.http.cache.maxSize", 1000); +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/ContentEncoding.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/ContentEncoding.java b/juneau-core/src/main/java/org/apache/juneau/http/ContentEncoding.java new file mode 100644 index 0000000..bb92921 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/ContentEncoding.java @@ -0,0 +1,74 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Content-Encoding</l> HTTP response header. + * <p> + * The type of encoding used on the data. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Content-Encoding: gzip + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Content-Encoding entity-header field is used as a modifier to the media-type. + * When present, its value indicates what additional content codings have been applied to the entity-body, and thus + * what decoding mechanisms must be applied in order to obtain the media-type referenced by the Content-Type header + * field. + * Content-Encoding is primarily used to allow a document to be compressed without losing the identity of its + * underlying media type. + * <p class='bcode'> + * Content-Encoding = "Content-Encoding" ":" 1#content-coding + * </p> + * <p> + * Content codings are defined in section 3.5. An example of its use is... + * <p class='bcode'> + * Content-Encoding: gzip + * </p> + * <p> + * The content-coding is a characteristic of the entity identified by the Request-URI. + * Typically, the entity-body is stored with this encoding and is only decoded before rendering or analogous usage. + * However, a non-transparent proxy MAY modify the content-coding if the new coding is known to be acceptable to the + * recipient, unless the "no-transform" cache-control directive is present in the message. + * <p> + * If the content-coding of an entity is not "identity", then the response MUST include a Content-Encoding + * entity-header (section 14.11) that lists the non-identity content-coding(s) used. + * <p> + * If the content-coding of an entity in a request message is not acceptable to the origin server, the server SHOULD + * respond with a status code of 415 (Unsupported Media Type). + * <p> + * If multiple encodings have been applied to an entity, the content codings MUST be listed in the order in which they + * were applied. + * Additional information about the encoding parameters MAY be provided. + */ +public final class ContentEncoding extends HeaderEnum<ContentEncodingEnum> { + + /** + * Returns a parsed <code>Content-Encoding</code> header. + * + * @param value The <code>Content-Encoding</code> header string. + * @return The parsed <code>Content-Encoding</code> header, or <jk>null</jk> if the string was null. + */ + public static ContentEncoding forString(String value) { + if (value == null) + return null; + return new ContentEncoding(value); + } + + private ContentEncoding(String value) { + super(value, ContentEncodingEnum.class, ContentEncodingEnum.OTHER); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/ContentEncodingEnum.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/ContentEncodingEnum.java b/juneau-core/src/main/java/org/apache/juneau/http/ContentEncodingEnum.java new file mode 100644 index 0000000..e44329a --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/ContentEncodingEnum.java @@ -0,0 +1,34 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents the possible values for a <code>Content-Encoding</code> header. + */ +public enum ContentEncodingEnum { + + /** Content-Encoding: gzip */ + GZIP, + + /** Content-Encoding: compress */ + COMPRESS, + + /** Content-Encoding: deflate */ + DEFLATE, + + /** Content-Encoding: identity */ + IDENTITY, + + /** Unknown value */ + OTHER; +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/ContentLanguage.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/ContentLanguage.java b/juneau-core/src/main/java/org/apache/juneau/http/ContentLanguage.java new file mode 100644 index 0000000..bfebcbe --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/ContentLanguage.java @@ -0,0 +1,78 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Content-Language</l> HTTP response header. + * <p> + * The natural language or languages of the intended audience for the enclosed content. + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Content-Language: da + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Content-Language entity-header field describes the natural language(s) of the intended audience for the + * enclosed entity. + * Note that this might not be equivalent to all the languages used within the entity-body. + * <p class='bcode'> + * Content-Language = "Content-Language" ":" 1#language-tag + * </p> + * <p> + * Language tags are defined in section 3.10. + * The primary purpose of Content-Language is to allow a user to identify and differentiate entities according to the + * user's own preferred language. + * Thus, if the body content is intended only for a Danish-literate audience, the appropriate field is... + * <p class='bcode'> + * Content-Language: da + * </p> + * <p> + * If no Content-Language is specified, the default is that the content is intended for all language audiences. + * This might mean that the sender does not consider it to be specific to any natural language, or that the sender + * does not know for which language it is intended. + * <p> + * Multiple languages MAY be listed for content that is intended for multiple audiences. + * For example, a rendition of the "Treaty of Waitangi," presented simultaneously in the original Maori and English + * versions, would call for... + * <p class='bcode'> + * Content-Language: mi, en + * </p> + * <p> + * However, just because multiple languages are present within an entity does not mean that it is intended for + * multiple linguistic audiences. + * An example would be a beginner's language primer, such as "A First Lesson in Latin," which is clearly intended to + * be used by an English-literate audience. + * In this case, the Content-Language would properly only include "en". + * <p> + * Content-Language MAY be applied to any media type -- it is not limited to textual documents. + */ +public final class ContentLanguage extends HeaderStringArray { + + /** + * Returns a parsed <code>Content-Language</code> header. + * + * @param value The <code>Content-Language</code> header string. + * @return The parsed <code>Content-Language</code> header, or <jk>null</jk> if the string was null. + */ + public static ContentLanguage forString(String value) { + if (value == null) + return null; + return new ContentLanguage(value); + } + + private ContentLanguage(String value) { + super(value); + } +} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/fa4736b6/juneau-core/src/main/java/org/apache/juneau/http/ContentLength.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/http/ContentLength.java b/juneau-core/src/main/java/org/apache/juneau/http/ContentLength.java new file mode 100644 index 0000000..9cb8959 --- /dev/null +++ b/juneau-core/src/main/java/org/apache/juneau/http/ContentLength.java @@ -0,0 +1,67 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.http; + +/** + * Represents a parsed <l>Content-Length</l> HTTP request/response header. + * <p> + * The length of the response body in octets (8-bit bytes). + * + * <h6 class='figure'>Example</h6> + * <p class='bcode'> + * Content-Length: 348 + * </p> + * + * <h6 class='topic'>RFC2616 Specification</h6> + * + * The Content-Length entity-header field indicates the size of the entity-body, in decimal number of OCTETs, sent to + * the recipient or, in the case of the HEAD method, the size of the entity-body that would have been sent had the + * request been a GET. + * <p class='bcode'> + * Content-Length = "Content-Length" ":" 1*DIGIT + * </p> + * <p> + * An example is... + * <p class='bcode'> + * Content-Length: 3495 + * </p> + * <p> + * Applications SHOULD use this field to indicate the transfer-length of the message-body, unless this is prohibited by + * the rules in section 4.4. + * <p> + * Any Content-Length greater than or equal to zero is a valid value. + * Section 4.4 describes how to determine the length of a message-body if a Content-Length is not given. + * <p> + * Note that the meaning of this field is significantly different from the corresponding definition in MIME, where it is + * an optional field used within the "message/external-body" content-type. + * In HTTP, it SHOULD be sent whenever the message's length can be determined prior to being transferred, unless this is + * prohibited by the rules in section 4.4. + */ +public final class ContentLength extends HeaderInteger { + + /** + * Returns a parsed <code>Content-Length</code> header. + * + * @param value The <code>Content-Length</code> header string. + * @return The parsed <code>Content-Length</code> header, or <jk>null</jk> if the string was null. + */ + public static ContentLength forString(String value) { + if (value == null) + return null; + return new ContentLength(value); + } + + private ContentLength(String value) { + super(value); + } +}
