You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wink.apache.org by bl...@apache.org on 2009/09/27 21:18:42 UTC
svn commit: r819385 - in
/incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts:
HttpHeadersImpl.java RequestImpl.java UriInfoImpl.java
Author: bluk
Date: Sun Sep 27 19:18:42 2009
New Revision: 819385
URL: http://svn.apache.org/viewvc?rev=819385&view=rev
Log:
Add debug statements to Contexts
Modified:
incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/HttpHeadersImpl.java
incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/RequestImpl.java
incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/UriInfoImpl.java
Modified: incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/HttpHeadersImpl.java
URL: http://svn.apache.org/viewvc/incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/HttpHeadersImpl.java?rev=819385&r1=819384&r2=819385&view=diff
==============================================================================
--- incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/HttpHeadersImpl.java (original)
+++ incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/HttpHeadersImpl.java Sun Sep 27 19:18:42 2009
@@ -45,9 +45,13 @@
import org.apache.wink.common.internal.utils.UnmodifiableMultivaluedMap;
import org.apache.wink.server.handlers.MessageContext;
import org.apache.wink.server.internal.DeploymentConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class HttpHeadersImpl implements HttpHeaders {
+ private final Logger logger = LoggerFactory.getLogger(HttpHeadersImpl.class);
+
private MessageContext msgContext;
private MultivaluedMap<String, String> headers;
private MultivaluedMap<String, String> allHeaders;
@@ -81,10 +85,12 @@
acceptLanguageTemp.append(requestHeader.get(c));
}
String acceptLanguage = acceptLanguageTemp.toString();
+ logger.debug("Accept-Language combined header is {}", acceptLanguage);
AcceptLanguage acceptLanguages = AcceptLanguage.valueOf(acceptLanguage);
acceptableLanguages = acceptLanguages.getAcceptableLanguages();
}
}
+ logger.debug("getAcceptableLanguages() returns {}", acceptableLanguages);
return acceptableLanguages;
}
@@ -93,6 +99,7 @@
Accept acceptHeader = getAcceptHeader();
acceptableMediaTypes = acceptHeader.getSortedMediaTypes();
}
+ logger.debug("getAcceptableMediaTypes() returns {}", acceptableMediaTypes);
return acceptableMediaTypes;
}
@@ -101,18 +108,21 @@
msgContext.getUriInfo().getQueryParameters()
.getFirst(RestConstants.REST_PARAM_MEDIA_TYPE);
String acceptValue = null;
+ logger.debug("alternateParameter is {}", alternateParameter);
if (alternateParameter != null) {
// try to map alternate parameter shortcut to a real media type
DeploymentConfiguration deploymentConfiguration =
msgContext.getAttribute(DeploymentConfiguration.class);
Map<String, String> alternateShortcutMap =
deploymentConfiguration.getAlternateShortcutMap();
+ logger.debug("alternateShortcutMap is {}", alternateShortcutMap);
if (alternateShortcutMap != null) {
acceptValue = alternateShortcutMap.get(alternateParameter);
}
if (acceptValue == null) {
acceptValue = alternateParameter;
}
+ logger.debug("acceptValue set via alternateParameter is {}", acceptValue);
} else {
List<String> requestHeader = getRequestHeader(HttpHeaders.ACCEPT);
if (requestHeader == null || requestHeader.isEmpty()) {
@@ -130,9 +140,12 @@
}
}
try {
+ logger.debug("Accept header is: {}", acceptValue);
Accept acceptHeader = Accept.valueOf(acceptValue);
+ logger.debug("getAcceptHeader() returns {}", acceptHeader);
return acceptHeader;
} catch (IllegalArgumentException e) {
+ logger.debug("Illegal Accept request header: {}", e);
throw new WebApplicationException(e, 400);
}
}
@@ -148,6 +161,7 @@
}
}
}
+ logger.debug("Cookies are: {}", cookies);
return cookies;
}
@@ -162,12 +176,15 @@
languageStr = s.get(0);
}
}
+ logger.debug("Language string is {}", languageStr);
if (languageStr == null) {
+ logger.debug("getLanguage() returning null");
return null;
}
String[] locales = StringUtils.fastSplit(languageStr, ",");
language = HeaderUtils.languageToLocale(locales[0].trim());
}
+ logger.debug("getLanguage() returning {}", language);
return language;
}
@@ -177,19 +194,24 @@
if (contentType == null) {
List<String> s = getRequestHeaderInternal(HttpHeaders.CONTENT_TYPE);
if (s == null || s.isEmpty()) {
+ logger.debug("getMediaType() returning null");
return null;
} else {
contentType = s.get(0);
}
}
+ logger.debug("Content-type is {}", contentType);
mediaType = MediaType.valueOf(contentType);
}
+ logger.debug("getMediaType() returning {}", mediaType);
return mediaType;
}
private List<String> getRequestHeaderInternal(String name) {
if (allHeaders != null) {
- return allHeaders.get(name);
+ List<String> value = allHeaders.get(name);
+ logger.debug("Returning {} header value from allHeaders cache: {}", name, value);
+ return value;
}
List<String> list = headers.get(name);
@@ -203,27 +225,35 @@
list.add(val);
}
}
-
+ logger
+ .debug("HttpServletRequest.getHeaders({}) returned {} so putting into headers cache",
+ name,
+ list);
headers.put(name, list);
}
-
+ logger.debug("getRequestHeaderInternal({}) returning {}", name, list);
return list;
}
public List<String> getRequestHeader(String name) {
if (name == null) {
+ logger.debug("getRequestHeader({}) returns null", name);
return null;
}
List<String> list = getRequestHeaderInternal(name);
if (list == null || list.isEmpty()) {
+ logger.debug("getRequestHeader({}) returns null due to empty or non-existent header",
+ name);
return null;
}
+ logger.debug("getRequestHeader({}) returns {}", name, list);
return Collections.unmodifiableList(list);
}
public MultivaluedMap<String, String> getRequestHeaders() {
if (allHeaders == null) {
allHeaders = buildRequestHeaders();
+ logger.debug("getRequests() called so building allHeaders cache", allHeaders);
}
return allHeaders;
@@ -248,6 +278,7 @@
values.add(val);
}
}
+ logger.debug("buildRequestHeaders() adding {} header with values {}", name, values);
map.put(name, values);
}
return new UnmodifiableMultivaluedMap<String, String>(map);
Modified: incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/RequestImpl.java
URL: http://svn.apache.org/viewvc/incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/RequestImpl.java?rev=819385&r1=819384&r2=819385&view=diff
==============================================================================
--- incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/RequestImpl.java (original)
+++ incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/RequestImpl.java Sun Sep 27 19:18:42 2009
@@ -42,8 +42,13 @@
import org.apache.wink.common.internal.http.AcceptLanguage;
import org.apache.wink.common.internal.http.EntityTagMatchHeader;
import org.apache.wink.server.handlers.MessageContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class RequestImpl implements Request {
+ private static final Logger logger =
+ LoggerFactory
+ .getLogger(RequestImpl.class);
private MessageContext msgContext;
private static final RuntimeDelegate delegate =
@@ -69,6 +74,7 @@
}
public ResponseBuilder evaluatePreconditions(EntityTag tag) {
+ logger.debug("evaluatePreconditions({}) called", tag);
String ifMatch = getHeaderValue(HttpHeaders.IF_MATCH);
if (ifMatch != null) {
return evaluateIfMatch(tag, ifMatch);
@@ -84,9 +90,11 @@
* returns ResponseBuilder if none of the tags matched
*/
private ResponseBuilder evaluateIfMatch(EntityTag tag, String headerValue) {
+ logger.debug("evaluateIfMatch({}, {}) called", tag, headerValue);
EntityTagMatchHeader ifMatchHeader = null;
try {
ifMatchHeader = ifMatchHeaderDelegate.fromString(headerValue);
+ logger.debug("ifMatchHeaderDelegate returned {}", ifMatchHeader);
} catch (IllegalArgumentException e) {
throw new WebApplicationException(e, Response.Status.BAD_REQUEST);
}
@@ -95,8 +103,10 @@
// none of the tags matches the etag
ResponseBuilder responseBuilder = delegate.createResponseBuilder();
responseBuilder.status(HttpServletResponse.SC_PRECONDITION_FAILED).tag(tag);
+ logger.debug("evaluateIfMatch returning built response because there was no match");
return responseBuilder;
}
+ logger.debug("evaluateIfMatch returning null because there was a match");
return null;
}
@@ -104,9 +114,11 @@
* returns ResponseBuilder if any of the tags matched
*/
private ResponseBuilder evaluateIfNoneMatch(EntityTag tag, String headerValue) {
+ logger.debug("evaluateIfNoneMatch({}, {}) called", tag, headerValue);
EntityTagMatchHeader ifNoneMatchHeader = null;
try {
ifNoneMatchHeader = ifMatchHeaderDelegate.fromString(headerValue);
+ logger.debug("ifMatchHeaderDelegate returned {}", ifNoneMatchHeader);
} catch (IllegalArgumentException e) {
throw new WebApplicationException(e, Response.Status.BAD_REQUEST);
}
@@ -116,16 +128,28 @@
ResponseBuilder responseBuilder = delegate.createResponseBuilder();
String method = getMethod();
if (method.equalsIgnoreCase("GET") || method.equalsIgnoreCase("HEAD")) {
+ logger
+ .debug("evaluateIfNoneMatch returning 304 Not Modified because the {} method matched",
+ method);
responseBuilder.status(HttpServletResponse.SC_NOT_MODIFIED).tag(tag);
} else {
+ logger
+ .debug("evaluateIfNoneMatch returning 412 Precondition Failed because the {} method matched",
+ method);
responseBuilder.status(HttpServletResponse.SC_PRECONDITION_FAILED).tag(tag);
}
return responseBuilder;
}
+ logger.debug("evaluateIfNoneMatch returning null because there was no match");
return null;
}
public ResponseBuilder evaluatePreconditions(Date lastModified) {
+ if (logger.isDebugEnabled()) {
+ logger.debug("evaluatePreconditions({}) called with {} date",
+ lastModified,
+ lastModified.getTime());
+ }
String ifModifiedSince = getHeaderValue(HttpHeaders.IF_MODIFIED_SINCE);
if (ifModifiedSince != null) {
return evaluateIfModifiedSince(lastModified, ifModifiedSince);
@@ -138,28 +162,46 @@
}
private ResponseBuilder evalueateIfUnmodifiedSince(Date lastModified, String headerValue) {
-
Date date = dateHeaderDelegate.fromString(headerValue);
+ if (logger.isDebugEnabled()) {
+ logger
+ .debug("evalueateIfUnmodifiedSince({}, {}) got Date {} from header so comparing {} is after {}",
+ new Object[] {lastModified, headerValue, date, lastModified.getTime(),
+ date.getTime()});
+ }
if (lastModified.after(date)) {
ResponseBuilder responseBuilder = delegate.createResponseBuilder();
responseBuilder.status(HttpServletResponse.SC_PRECONDITION_FAILED);
+ logger.debug("evalueateIfUnmodifiedSince returning 412 Precondition Failed");
return responseBuilder;
}
+ logger.debug("evalueateIfUnmodifiedSince returning null");
return null;
}
private ResponseBuilder evaluateIfModifiedSince(Date lastModified, String headerValue) {
Date date = dateHeaderDelegate.fromString(headerValue);
+ if (logger.isDebugEnabled()) {
+ logger
+ .debug("evaluateIfModifiedSince({}, {}) got Date {} from header so comparing {} is after {}",
+ new Object[] {lastModified, headerValue, date, lastModified.getTime(),
+ date.getTime()});
+ }
if (lastModified.after(date)) {
+ logger.debug("evaluateIfModifiedSince returning null");
return null;
}
ResponseBuilder responseBuilder = delegate.createResponseBuilder();
responseBuilder.status(HttpServletResponse.SC_NOT_MODIFIED);
+ logger.debug("evaluateIfModifiedSince returning 304 Not Modified");
return responseBuilder;
}
public ResponseBuilder evaluatePreconditions(Date lastModified, EntityTag tag) {
-
+ if (logger.isDebugEnabled()) {
+ logger.debug("evaluatePreconditions({}, {}) called with date {} as a long type",
+ new Object[] {lastModified, tag, lastModified.getTime()});
+ }
String ifMatch = getHeaderValue(HttpHeaders.IF_MATCH);
if (ifMatch != null) {
return evaluateIfMatch(tag, ifMatch);
@@ -194,11 +236,13 @@
}
public Variant selectVariant(List<Variant> variants) throws IllegalArgumentException {
+ logger.debug("selectVariant({}) called", variants);
if (variants == null) {
throw new IllegalArgumentException();
}
if (variants.size() == 0) {
+ logger.debug("No variants so returning null");
return null;
}
@@ -244,11 +288,15 @@
for (Iterator<Variant> iter = variants.iterator(); iter.hasNext();) {
double acceptQFactor = -1.0d;
Variant v = iter.next();
+ logger.debug("Variant being evaluated is: {}", v);
MediaType vMediaType = v.getMediaType();
if (vMediaType != null && acceptableMediaTypes != null) {
boolean isCompatible = false;
boolean isAcceptable = true; // explicitly denied by the client
for (MediaType mt : acceptableMediaTypes) {
+ logger.debug("Checking variant media type {} against Accept media type {}",
+ vMediaType,
+ mt);
if (mt.isCompatible(vMediaType)) {
Map<String, String> params = mt.getParameters();
String q = params.get("q");
@@ -257,27 +305,41 @@
Double qAsDouble = Double.valueOf(q);
if (qAsDouble.equals(0.0)) {
isAcceptable = false;
+ logger
+ .debug("Accept Media Type: {} is NOT compatible with q-factor {}",
+ mt,
+ qAsDouble);
break;
}
acceptQFactor = qAsDouble;
} catch (NumberFormatException e) {
- // silently ignore
- e.printStackTrace();
+ logger
+ .debug("NumberFormatException during MediaType q-factor evaluation: {}",
+ e);
}
} else {
acceptQFactor = 1.0d;
}
+
isCompatible = true;
+ logger.debug("Accept Media Type: {} is compatible with q-factor {}",
+ mt,
+ acceptQFactor);
break;
}
}
if (!isCompatible || !isAcceptable) {
+ logger.debug("Variant {} is not compatible or not acceptable", vMediaType);
continue;
}
}
if (bestVariant != null) {
if (acceptQFactor < bestVariant.acceptMediaTypeQFactor) {
+ logger
+ .debug("Best variant's media type {} q-factor {} is greater than current variant {} q-factor {}",
+ new Object[] {bestVariant.variant,
+ bestVariant.acceptMediaTypeQFactor, vMediaType, acceptQFactor});
continue;
}
}
@@ -286,23 +348,35 @@
Locale vLocale = v.getLanguage();
if (vLocale != null && languages != null) {
boolean isCompatible = false;
+ logger.debug("Checking variant locale {}", vLocale);
if (languages.getBannedLanguages().contains(vLocale)) {
+ logger.debug("Variant locale {} was in unacceptable languages", vLocale);
continue;
}
for (AcceptLanguage.ValuedLocale locale : languages.getValuedLocales()) {
+ logger
+ .debug("Checking against Accept-Language locale {} with quality factor {}",
+ locale.locale,
+ locale.qValue);
if (locale.isWildcard() || vLocale.equals(locale.locale)) {
+ logger.debug("Locale is compatible {}", locale.locale);
isCompatible = true;
acceptLanguageQFactor = locale.qValue;
break;
}
}
if (!isCompatible) {
+ logger.debug("Variant locale is not compatible {}", vLocale);
continue;
}
}
if (bestVariant != null) {
if (acceptLanguageQFactor < bestVariant.acceptLanguageQFactor) {
+ logger
+ .debug("Best variant's language {} q-factor {} is greater than current variant {} q-factor {}",
+ new Object[] {bestVariant.variant,
+ bestVariant.acceptLanguageQFactor, v, acceptLanguageQFactor});
continue;
}
}
@@ -310,17 +384,26 @@
double acceptEncodingQFactor = -1.0d;
String vEncoding = v.getEncoding();
if (vEncoding != null) {
+ logger.debug("Checking variant encoding {}", vEncoding);
if (encodings == null || encodings.isAnyEncodingAllowed()) {
+ logger.debug("Accept-Encoding is null or wildcard");
if (!v.getEncoding().equalsIgnoreCase("identity")) {
+ logger
+ .debug("Variant encoding {} does not equal identity so not acceptable",
+ vEncoding);
// if there is no Accept Encoding, only identity is
// acceptable
+ // mark that identity encoding was checked so that the
+ // Vary header has Accept-Encoding added appropriately
isIdentityEncodingChecked = true;
continue;
}
} else {
boolean isAcceptable = true;
for (String encoding : encodings.getBannedEncodings()) {
+ logger.debug("Checking against not acceptable encoding: {}", encoding);
if (encoding.equalsIgnoreCase(vEncoding)) {
+ logger.debug("Encoding was not acceptable: {}", vEncoding);
isAcceptable = false;
break;
}
@@ -331,13 +414,18 @@
boolean isCompatible = false;
for (AcceptEncoding.ValuedEncoding encoding : encodings.getValuedEncodings()) {
+ logger.debug("Checking against acceptable encoding: {}", encoding.encoding);
if (encoding.isWildcard() || encoding.encoding.equalsIgnoreCase(vEncoding)) {
isCompatible = true;
acceptEncodingQFactor = encoding.qValue;
+ logger.debug("Encoding {} was acceptable with q-factor {}",
+ encoding.encoding,
+ encoding.qValue);
break;
}
}
if (!isCompatible) {
+ logger.debug("Variant encoding {} was not compatible", vEncoding);
continue;
}
}
@@ -345,6 +433,10 @@
if (bestVariant != null) {
if (acceptEncodingQFactor < bestVariant.acceptEncodingQFactor) {
+ logger
+ .debug("Best variant's encoding {} q-factor {} is greater than current variant {} q-factor {}",
+ new Object[] {bestVariant.variant,
+ bestVariant.acceptEncodingQFactor, v, acceptEncodingQFactor});
continue;
}
}
@@ -377,9 +469,9 @@
varyHeaderValue.append(HttpHeaders.ACCEPT_ENCODING);
isValueWritten = true;
}
-
- msgContext.setAttribute(RequestImpl.VaryHeader.class, new VaryHeader(varyHeaderValue
- .toString().trim()));
+ String varyHeaderValueStr = varyHeaderValue.toString().trim();
+ logger.debug("Vary Header value should be set to {}", varyHeaderValueStr);
+ msgContext.setAttribute(RequestImpl.VaryHeader.class, new VaryHeader(varyHeaderValueStr));
return bestVariant.variant;
}
Modified: incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/UriInfoImpl.java
URL: http://svn.apache.org/viewvc/incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/UriInfoImpl.java?rev=819385&r1=819384&r2=819385&view=diff
==============================================================================
--- incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/UriInfoImpl.java (original)
+++ incubator/wink/trunk/wink-server/src/main/java/org/apache/wink/server/internal/contexts/UriInfoImpl.java Sun Sep 27 19:18:42 2009
@@ -87,11 +87,14 @@
String requestPath = getPath(false);
absolutePath = getBaseUri().resolve(requestPath);
}
+ logger.debug("getAbsolutePath() returning: {}", absolutePath);
return absolutePath;
}
public UriBuilder getAbsolutePathBuilder() {
- return UriBuilder.fromUri(getAbsolutePath());
+ UriBuilder builder = UriBuilder.fromUri(getAbsolutePath());
+ logger.debug("getAbsolutePathBuilder() returning: {}", builder);
+ return builder;
}
public URI getBaseUri() {
@@ -103,16 +106,22 @@
logger.error(Messages.getMessage("uriBadBaseURI") + baseUriString, e);
}
}
+ logger.debug("getBaseUri() returning: {}", baseUri);
return baseUri;
}
public UriBuilder getBaseUriBuilder() {
- return UriBuilder.fromUri(getBaseUri());
+ UriBuilder builder = UriBuilder.fromUri(getBaseUri());
+ logger.debug("getBaseUriBuilder() returning: {}", builder);
+ return builder;
}
public List<ResourceInstance> getMatchedResourceInstances() {
- return Collections.unmodifiableList(messageContext.getAttribute(SearchResult.class)
- .getData().getMatchedResources());
+ List<ResourceInstance> resources =
+ Collections.unmodifiableList(messageContext.getAttribute(SearchResult.class).getData()
+ .getMatchedResources());
+ logger.debug("getMatchedResourceInstances() returning: {}", resources);
+ return resources;
}
public List<Object> getMatchedResources() {
@@ -122,7 +131,7 @@
for (ResourceInstance resourceInstance : matchedResources) {
resourceList.add(resourceInstance.getInstance(messageContext));
}
-
+ logger.debug("getMatchedResources() returning: {}", resourceList);
return Collections.unmodifiableList(resourceList);
}
@@ -131,6 +140,7 @@
}
public List<String> getMatchedURIs(boolean decode) {
+ logger.debug("getMatchedURIs({}) called", decode);
List<List<PathSegment>> matchedURIs =
messageContext.getAttribute(SearchResult.class).getData().getMatchedURIs();
if (matchedURIsStrings != null && matchedURIsStrings.size() != matchedURIs.size()) {
@@ -141,6 +151,7 @@
if (matchedURIsStrings == null) {
matchedURIsStrings = new ArrayList<String>(matchedURIs.size());
for (List<PathSegment> segments : matchedURIs) {
+ logger.debug("Adding matched URI: {}", segments);
matchedURIsStrings.add(PathSegmentImpl.toString(segments));
}
}
@@ -150,12 +161,14 @@
if (decodedMatchedURIsStrings == null) {
decodedMatchedURIsStrings = new ArrayList<String>(matchedURIsStrings.size());
for (String uri : matchedURIsStrings) {
- decodedMatchedURIsStrings.add(UriEncoder.decodeString(uri));
+ String decodedUri = UriEncoder.decodeString(uri);
+ decodedMatchedURIsStrings.add(decodedUri);
+ logger.debug("Adding decoded URI: {} from URI: {}", decodedUri, uri);
}
}
list = decodedMatchedURIsStrings;
}
-
+ logger.debug("getMatchedURIs({}) returning {}", decode, list);
return Collections.unmodifiableList(list);
}
@@ -164,14 +177,17 @@
}
public String getPath(boolean decode) {
+ logger.debug("getPath({}) called", decode);
if (path == null) {
path = buildRequestPath(messageContext.getAttribute(HttpServletRequest.class));
}
if (decode) {
- return UriEncoder.decodeString(path);
+ String decodedPath = UriEncoder.decodeString(path);
+ logger.debug("getPath({}) returning {}", decode, decodedPath);
+ return decodedPath;
}
-
+ logger.debug("getPath({}) returning {}", decode, path);
return path;
}
@@ -180,6 +196,7 @@
}
public MultivaluedMap<String, String> getPathParameters(boolean decode) {
+ logger.debug("getPathParameters({}) called", decode);
if (pathParameters == null) {
pathParameters = new MultivaluedMapImpl<String, String>();
SearchResult searchResult = messageContext.getAttribute(SearchResult.class);
@@ -187,6 +204,9 @@
throw new IllegalStateException("outside the scope of a request");
}
MultivaluedMapImpl.copy(searchResult.getData().getMatchedVariables(), pathParameters);
+ logger.debug("getPathParameters({}) encoded path parameters are: {}",
+ decode,
+ pathParameters);
}
MultivaluedMap<String, String> map = pathParameters;
@@ -197,6 +217,7 @@
map = decodedPathParameters;
}
+ logger.debug("getPathParameters({}) returning {}", decode, map);
return map;
}
@@ -209,8 +230,12 @@
}
public List<PathSegment> getPathSegments(boolean decode) {
+ logger.debug("getPathSegments({}) called", decode);
if (pathSegments == null) {
pathSegments = UriHelper.parsePath(getPath(false));
+ logger.debug("getPathSegments({}) encoded path parameters are: {}",
+ decode,
+ pathSegments);
}
List<PathSegment> list = pathSegments;
@@ -220,7 +245,7 @@
}
list = decodedPathSegments;
}
-
+ logger.debug("getPathSegments({}) returning {}", decode, list);
return list;
}
@@ -229,10 +254,15 @@
}
public MultivaluedMap<String, String> getQueryParameters(boolean decode) {
+ logger.debug("getQueryParameters({}) called", decode);
if (queryParameters == null) {
queryParameters = new MultivaluedMapImpl<String, String>();
String query = messageContext.getAttribute(HttpServletRequest.class).getQueryString();
+ logger.debug("getQueryParameters({}) query string is: {}", decode, query);
queryParameters = UriHelper.parseQuery(query);
+ logger.debug("getQueryParameters({}) encoded query parameters are: {}",
+ decode,
+ queryParameters);
}
MultivaluedMap<String, String> map = queryParameters;
@@ -242,18 +272,26 @@
}
map = decodedQueryParameters;
}
+ logger.debug("getQueryParameters({}) returning {}", decode, map);
return map;
}
public URI getRequestUri() {
+ logger.debug("getRequestUri() called");
UriBuilder builder = getAbsolutePathBuilder();
String query = messageContext.getAttribute(HttpServletRequest.class).getQueryString();
+ logger.debug("getRequestUri() query string: {}", query);
builder.replaceQuery(query);
- return builder.build();
+ logger.debug("getRequestUri() build after query replacement: {}", builder);
+ URI uri = builder.build();
+ logger.debug("getRequestUri() returning: {}", uri);
+ return uri;
}
public UriBuilder getRequestUriBuilder() {
- return UriBuilder.fromUri(getRequestUri());
+ UriBuilder builder = UriBuilder.fromUri(getRequestUri());
+ logger.debug("getRequestUriBuilder() returning: {}", builder);
+ return builder;
}
private String getBaseUriString() {
@@ -262,6 +300,7 @@
buildBaseUriString(messageContext.getAttribute(HttpServletRequest.class),
messageContext.getProperties());
}
+ logger.debug("getBaseUriString() returned {}", baseUriString);
return baseUriString;
}
@@ -281,29 +320,35 @@
String baseURI = httpURI;
if (request.isSecure()) {
+ logger.debug("buildBaseUriString request is secure");
baseURI = httpsURI;
}
+ logger.debug("buildBaseUriString baseURI from properties is: {}", baseURI);
if (baseURI == null) {
baseURI = autodetectBaseUri(request);
+ logger.debug("buildBaseUriString baseURI from autodetectBaseUri is: {}", baseURI);
}
return appendContextAndServletPath(baseURI, request, properties);
}
private String getURI(Properties properties, String propertyName) {
String uri = properties.getProperty(propertyName);
+ logger.debug("getURI({}, {}) called", properties, propertyName);
if (uri != null && uri.length() != 0) {
try {
URI uriParsed = new URI(uri);
+ logger.debug("getURI({}, {}) returning {}", new Object[] {properties, propertyName,
+ uriParsed});
return uriParsed.toString();
} catch (URISyntaxException e) {
throw new IllegalArgumentException("invalid URI", e);
}
}
+ logger.debug("getURI({}, {}) returning null", properties, propertyName);
return null;
}
private static String autodetectBaseUri(HttpServletRequest request) {
-
try {
return new URI(request.getScheme(), null, request.getServerName(), request
.getServerPort(), "/", null, null).toString();
@@ -315,7 +360,8 @@
private String appendContextAndServletPath(String basePath,
HttpServletRequest request,
Properties properties) {
-
+ logger.debug("appendContextAndServletPath({}, {}, {}) called", new Object[] {basePath,
+ request, properties});
StringBuilder builder = new StringBuilder(basePath);
if (builder.charAt(builder.length() - 1) == '/') {
builder.deleteCharAt(builder.length() - 1);
@@ -326,37 +372,47 @@
.getContextPath());
if (contextPath != null) {
builder.append(contextPath);
+ logger.debug("appendContextAndServletPath after contextPath called is: {} ", builder);
}
boolean isServlet =
RuntimeContextTLS.getRuntimeContext().getAttribute(FilterConfig.class) == null;
+ logger.debug("appendContextAndServletPath isServlet: {} ", isServlet);
if (request.getServletPath() != null && isServlet) {
builder.append(request.getServletPath());
+ logger
+ .debug("appendContextAndServletPath after getServletPath called is: {} ", builder);
}
if (builder.charAt(builder.length() - 1) != '/') {
builder.append('/');
}
- return builder.toString();
+ String builderStr = builder.toString();
+ logger.debug("appendContextAndServletPath returning: {} ", builderStr);
+ return builderStr;
}
private static String buildRequestPath(HttpServletRequest request) {
// we cannot use request.getPathInfo() since it cuts off the ';'
// parameters on Tomcat
String requestPath = request.getRequestURI();
-
+ logger.debug("buildRequestPath requestPath is: {}", requestPath);
// Syntax-Based Normalization (RFC 3986, section 6.2.2)
requestPath = UriHelper.normalize(requestPath);
-
+ logger.debug("buildRequestPath requestPath normalized is: {}", requestPath);
// cut off the context path from the beginning
if (request.getContextPath() != null) {
requestPath = requestPath.substring(request.getContextPath().length());
+ logger.debug("buildRequestPath after context path removed: {}", requestPath);
}
// cut off the servlet path from the beginning
boolean isServlet =
RuntimeContextTLS.getRuntimeContext().getAttribute(FilterConfig.class) == null;
+ logger.debug("buildRequestPath isServlet: {}", isServlet);
if (request.getServletPath() != null && isServlet) {
requestPath = requestPath.substring(request.getServletPath().length());
+ logger
+ .debug("buildRequestPath requestPath after servlet path removed: {}", requestPath);
}
// cut off all leading /
@@ -365,7 +421,7 @@
++index;
}
requestPath = requestPath.substring(index);
-
+ logger.debug("buildRequestPath returning requestPath: {}", requestPath);
return requestPath;
}
}