public List<Preference> getAccept() { return headers.getAccept(); }
public List<Preference> getAcceptCharset() { return headers.getAcceptCharset(); }
private Headers getResponseHeaders(HttpURLConnection connection) { Headers headers = new Headers(); Map<String, List<String>> headerFields = connection.getHeaderFields(); for (Map.Entry<String, List<String>> entry : headerFields.entrySet()) { for (String headerValue : entry.getValue()) { if (entry.getKey() != null) { headers = headers.add(entry.getKey(), headerValue); } } } return headers; }
/** * Analyses the headers in the given request to figure out if this {@link Vary variation} matches. * * @param request the request to analyse * @return {@code true} if the request matches the variance. {@code false} if not. */ //todo: cleanup this public boolean matches(final HTTPRequest request) { if (varyHeaders.containsKey("ALL")) return false; Headers headers = request.getAllHeaders(); for (Map.Entry<String, String> varyEntry : varyHeaders.entrySet()) { if (request.getChallenge().isPresent() && varyEntry.getKey().equals(HeaderConstants.AUTHORIZATION)) { if (!request.getChallenge().get().getIdentifier().equals(varyEntry.getValue())) { return false; } } else { List<Header> requestHeaderValue = headers.getHeaders(varyEntry.getKey()); boolean valid = requestHeaderValue.isEmpty() ? varyEntry.getValue() == null : headers.getFirstHeader(varyEntry.getKey()).get().getValue().equals(varyEntry.getValue()); if (!valid) { return false; } } } List<Preference> preferences = new ArrayList<>(); preferences.addAll(headers.getAccept()); preferences.addAll(headers.getAcceptCharset()); preferences.addAll(headers.getAcceptLanguage()); return !(varyHeaders.isEmpty() && !preferences.isEmpty()); }
if (headers.contains(VARY_ALL)) { return false; if (headers.contains(CACHE_CONTROL)) { Optional<CacheControl> cc = headers.getCacheControl(); if (OptionalUtils.exists(cc, (cc2 -> cc2.isNoCache() || cc2.isNoStore()))) { return false; if (headers.contains(PRAGMA)) { Optional<String> header = headers.getFirstHeaderValue(PRAGMA); if (OptionalUtils.exists(header, s -> s.contains(NO_CACHE_HEADER_VALUE))) { return false; if (headers.contains(EXPIRES)) { Optional<LocalDateTime> expires = headers.getExpires(); Optional<LocalDateTime> date = headers.getDate(); if (!expires.isPresent() || !date.isPresent()) { return false;
public void add(Iterable<Header> headers) { this.headers = this.headers.add(headers); }
public Optional<String> getFirstHeaderValue(String headerKey) { Optional<Header> header = getFirstHeader(headerKey); return header.map(Header::getValue); }
public static long getTTL(HTTPResponse response, int defaultTTLinSeconds) { final Optional<CacheControl> cc = response.getHeaders().getCacheControl(); if (cc.isPresent()) { int maxAge = cc.get().getMaxAge(); if (maxAge > 0) { return maxAge; } } /** * HTTP/1.1 clients and caches MUST treat other invalid date formats, especially including the value "0", as in the past (i.e., "already expired"). * To mark a response as "already expired," an origin server sends an Expires date that is equal to the Date header value. * (See the rules for expiration calculations in section 13.2.4.) * To mark a response as "never expires," an origin server sends an Expires date approximately one year from the time the response is sent. * HTTP/1.1 servers SHOULD NOT send Expires dates more than one year in the future. */ Optional<LocalDateTime> expires = response.getHeaders().getExpires(); if (expires.isPresent()) { LocalDateTime expiryDate = expires.get(); Optional<LocalDateTime> date = response.getHeaders().getDate(); if (OptionalUtils.exists(date, dt -> dt.isBefore(expiryDate))) { return Duration.between(date.get(), expiryDate).getSeconds(); } } return defaultTTLinSeconds; }
public static HTTPResponse createResponse(final StatusLine line, final Headers responseHeaders, final Optional<InputStream> stream) { Optional<String> contentLengthHeader = responseHeaders.getFirstHeaderValue(HeaderConstants.CONTENT_LENGTH); MIMEType type = responseHeaders.getContentType().orElse(MIMEType.APPLICATION_OCTET_STREAM); Optional<Long> length = responseHeaders.getContentLength(); Optional<Payload> payload = stream. filter(is -> line.getStatus().isBodyContentAllowed()). map(is -> new InputStreamPayload(is, type, length.orElse(-1L))); return new HTTPResponse(payload, line, responseHeaders); } }
/** * Converts the Conditionals into real headers. * @return real headers. */ public Headers toHeaders() { Headers headers = new Headers(); if (!getMatch().isEmpty()) { headers = headers.add(new Header(HeaderConstants.IF_MATCH, buildTagHeaderValue(getMatch()))); } if (!getNoneMatch().isEmpty()) { headers = headers.add(new Header(HeaderConstants.IF_NONE_MATCH, buildTagHeaderValue(getNoneMatch()))); } if (modifiedSince.isPresent()) { headers = headers.set(HeaderUtils.toHttpDate(HeaderConstants.IF_MODIFIED_SINCE, modifiedSince.get())); } if (unModifiedSince.isPresent()) { headers = headers.set(HeaderUtils.toHttpDate(HeaderConstants.IF_UNMODIFIED_SINCE, unModifiedSince.get())); } return headers; }
public Headers set(Header header) { HeaderHashMap headers = copyMap(); String normalized = normalizeValue(header.getName(), header.getValue()); headers.put(header.getName(), new ArrayList<>(Arrays.asList(normalized))); return new Headers(headers); }
public static Conditionals valueOf(Headers headers) { List<Tag> ifMatch = makeTags(headers.getFirstHeaderValue(HeaderConstants.IF_MATCH).orElse(null)); List<Tag> ifNoneMatch = makeTags(headers.getFirstHeaderValue(HeaderConstants.IF_NONE_MATCH).orElse(null)); Optional<LocalDateTime> modifiedSince = headers.getFirstHeader(HeaderConstants.IF_MODIFIED_SINCE).flatMap(HeaderUtils::fromHttpDate); Optional<LocalDateTime> unModifiedSince = headers.getFirstHeader(HeaderConstants.IF_UNMODIFIED_SINCE).flatMap(HeaderUtils::fromHttpDate); return new Conditionals(ifMatch, ifNoneMatch, modifiedSince, unModifiedSince); }
public MutableHeaders() { this(new Headers()); }
public static CacheItem parse(Properties object) { Optional<LocalDateTime> time = HeaderUtils.fromHttpDate(new Header("cache-time", object.getProperty("cache-time"))); Status status = Status.valueOf(NumberUtils.toInt(object.getProperty("status"), 200)); Headers headers = Headers.parse(object.getProperty("headers")); Optional<Payload> p = Optional.empty(); if (object.containsKey("file")) { p = Optional.of(new FilePayload(new File(object.getProperty("file")), headers.getContentType().get())); } return new DefaultCacheItem(new HTTPResponse(p, status, headers), time.get()); }
public Optional<CacheControl> getCacheControl() { return headers.getCacheControl(); }
public List<Preference> getAcceptLanguage() { return headers.getAcceptLanguage(); }
public LocalDateTime getExpires() { return headers.getExpires().orElse(null); }
public LocalDateTime getDate() { return headers.getDate().orElse(null); }