struts-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lukaszlen...@apache.org
Subject [3/4] struts git commit: WW-4518 Moves results to dedicated package
Date Tue, 23 Jun 2015 15:14:41 GMT
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
index 82d2a55..f10cd48 100644
--- a/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
+++ b/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
@@ -27,7 +27,7 @@ import com.opensymphony.xwork2.interceptor.ValidationAware;
 import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.apache.struts2.dispatcher.ServletRedirectResult;
+import org.apache.struts2.result.ServletRedirectResult;
 
 import java.util.ArrayList;
 import java.util.Collection;

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java b/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
new file mode 100644
index 0000000..4745475
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
@@ -0,0 +1,210 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.Result;
+import com.opensymphony.xwork2.util.TextParseUtil;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ * <p/>
+ * A custom Result type for setting HTTP headers and status by optionally evaluating against the ValueStack.
+ * This result can also be used to send and error to the client. All the parameters can be evaluated against the ValueStack.
+ * <p/>
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ * <p/>
+ * <!-- START SNIPPET: params -->
+ * <p/>
+ * <ul>
+ * <p/>
+ * <li><b>status</b> - the http servlet response status code that should be set on a response.</li>
+ * <p/>
+ * <li><b>parse</b> - true by default. If set to false, the headers param will not be parsed for Ognl expressions.</li>
+ * <p/>
+ * <li><b>headers</b> - header values.</li>
+ * <p/>
+ * <li><b>error</b> - the http servlet response error code that should be set on a response.</li>
+ * <p/>
+ * <li><b>errorMessage</b> - error message to be set on response if 'error' is set.</li>
+ * </ul>
+ * <p/>
+ * <!-- END SNIPPET: params -->
+ * <p/>
+ * <b>Example:</b>
+ * <p/>
+ * <pre><!-- START SNIPPET: example -->
+ * &lt;result name="success" type="httpheader"&gt;
+ *   &lt;param name="status"&gt;204&lt;/param&gt;
+ *   &lt;param name="headers.a"&gt;a custom header value&lt;/param&gt;
+ *   &lt;param name="headers.b"&gt;another custom header value&lt;/param&gt;
+ * &lt;/result&gt;
+ * <p/>
+ * &lt;result name="proxyRequired" type="httpheader"&gt;
+ *   &lt;param name="error"&gt;305&lt;/param&gt;
+ *   &lt;param name="errorMessage"&gt;this action must be accessed through a prozy&lt;/param&gt;
+ * &lt;/result&gt;
+ * <!-- END SNIPPET: example --></pre>
+ */
+public class HttpHeaderResult implements Result {
+
+    private static final long serialVersionUID = 195648957144219214L;
+    private static final Logger LOG = LogManager.getLogger(HttpHeaderResult.class);
+
+    /**
+     * This result type doesn't have a default param, null is ok to reduce noise in logs
+     */
+    public static final String DEFAULT_PARAM = null;
+
+    private boolean parse = true;
+    private Map<String, String> headers;
+    private int status = -1;
+    private String error = null;
+    private String errorMessage;
+
+    public HttpHeaderResult() {
+        super();
+        headers = new HashMap<>();
+    }
+
+    public HttpHeaderResult(int status) {
+        this();
+        this.status = status;
+        this.parse = false;
+    }
+
+    /**
+     * Sets the http servlet error code that should be set on the response
+     *
+     * @param error the Http error code
+     * @see javax.servlet.http.HttpServletResponse#sendError(int)
+     */
+    public void setError(String error) {
+        this.error = error;
+    }
+
+    /**
+     * Sets the error message that should be set on the reponse
+     *
+     * @param errorMessage error message send to the client
+     * @see javax.servlet.http.HttpServletResponse#sendError(int, String)
+     */
+    public void setErrorMessage(String errorMessage) {
+        this.errorMessage = errorMessage;
+    }
+
+    /**
+     * Returns a Map of all HTTP headers.
+     *
+     * @return a Map of all HTTP headers.
+     */
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    /**
+     * Sets whether or not the HTTP header values should be evaluated against the ValueStack (by default they are).
+     *
+     * @param parse <tt>true</tt> if HTTP header values should be evaluated against the ValueStack, <tt>false</tt>
+     *              otherwise.
+     */
+    public void setParse(boolean parse) {
+        this.parse = parse;
+    }
+
+    /**
+     * Sets the http servlet response status code that should be set on a response.
+     *
+     * @param status the Http status code
+     * @see javax.servlet.http.HttpServletResponse#setStatus(int)
+     */
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    /**
+     * Adds an HTTP header to the response
+     *
+     * @param name  header name
+     * @param value header value
+     */
+    public void addHeader(String name, String value) {
+        headers.put(name, value);
+    }
+
+    /**
+     * Sets the optional HTTP response status code and also re-sets HTTP headers after they've
+     * been optionally evaluated against the ValueStack.
+     *
+     * @param invocation an encapsulation of the action execution state.
+     * @throws Exception if an error occurs when re-setting the headers.
+     */
+    public void execute(ActionInvocation invocation) throws Exception {
+        HttpServletResponse response = ServletActionContext.getResponse();
+        ValueStack stack = ActionContext.getContext().getValueStack();
+
+        if (status != -1) {
+            response.setStatus(status);
+        }
+
+        if (headers != null) {
+            for (Map.Entry<String, String> entry : headers.entrySet()) {
+                String value = entry.getValue();
+                String finalValue = parse ? TextParseUtil.translateVariables(value, stack) : value;
+                response.addHeader(entry.getKey(), finalValue);
+            }
+        }
+
+        if (status == -1 && error != null) {
+            int errorCode = -1;
+            try {
+                errorCode = Integer.parseInt(parse ? TextParseUtil.translateVariables(error, stack) : error);
+            } catch (Exception e) {
+                LOG.error("Cannot parse errorCode [{}] value as Integer!", error, e);
+            }
+            if (errorCode != -1) {
+                if (errorMessage != null) {
+                    String finalMessage = parse ? TextParseUtil.translateVariables(errorMessage, stack) : errorMessage;
+                    response.sendError(errorCode, finalMessage);
+                } else {
+                    response.sendError(errorCode);
+                }
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/PlainTextResult.java b/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
new file mode 100644
index 0000000..44d9302
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
@@ -0,0 +1,183 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * A result that send the content out as plain text. Useful typically when needed
+ * to display the raw content of a JSP or Html file for example.
+ *
+ * <!-- END SNIPPET: description -->
+ *
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *  <li>location (default) = location of the file (jsp/html) to be displayed as plain text.</li>
+ *  <li>charSet (optional) = character set to be used. This character set will be used to set the
+ *  response type (eg. Content-Type=text/plain; charset=UTF-8) and when reading
+ *  using a Reader. Some example of charSet would be UTF-8, ISO-8859-1 etc.
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ *
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ *
+ * &lt;action name="displayJspRawContent" &gt;
+ *   &lt;result type="plainText"&gt;/myJspFile.jsp&lt;/result&gt;
+ * &lt;/action&gt;
+ *
+ *
+ * &lt;action name="displayJspRawContent" &gt;
+ *   &lt;result type="plainText"&gt;
+ *      &lt;param name="location"&gt;/myJspFile.jsp&lt;/param&gt;
+ *      &lt;param name="charSet"&gt;UTF-8&lt;/param&gt;
+ *   &lt;/result&gt;
+ * &lt;/action&gt;
+ *
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ *
+ */
+public class PlainTextResult extends StrutsResultSupport {
+
+    public static final int BUFFER_SIZE = 1024;
+
+    private static final Logger LOG = LogManager.getLogger(PlainTextResult.class);
+
+    private static final long serialVersionUID = 3633371605905583950L;
+
+    private String charSet;
+
+    public PlainTextResult() {
+        super();
+    }
+
+    public PlainTextResult(String location) {
+        super(location);
+    }
+
+    /**
+     * Set the character set
+     *
+     * @return The character set
+     */
+    public String getCharSet() {
+        return charSet;
+    }
+
+    /**
+     * Set the character set
+     *
+     * @param charSet The character set
+     */
+    public void setCharSet(String charSet) {
+        this.charSet = charSet;
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.struts2.result.StrutsResultSupport#doExecute(java.lang.String, com.opensymphony.xwork2.ActionInvocation)
+     */
+    protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+        // verify charset
+        Charset charset = readCharset();
+
+        HttpServletResponse response = (HttpServletResponse) invocation.getInvocationContext().get(HTTP_RESPONSE);
+
+        applyCharset(charset, response);
+        applyAdditionalHeaders(response);
+        String location = adjustLocation(finalLocation);
+
+        try (PrintWriter writer = response.getWriter();
+                InputStream resourceAsStream = readStream(invocation, location);
+                InputStreamReader reader = new InputStreamReader(resourceAsStream, charset == null ? Charset.defaultCharset() : charset)) {
+            logWrongStream(finalLocation, resourceAsStream);
+            sendStream(writer, reader);
+        }
+    }
+
+    protected InputStream readStream(ActionInvocation invocation, String location) {
+        ServletContext servletContext = (ServletContext) invocation.getInvocationContext().get(SERVLET_CONTEXT);
+        return servletContext.getResourceAsStream(location);
+    }
+
+    protected void logWrongStream(String finalLocation, InputStream resourceAsStream) {
+        if (resourceAsStream == null) {
+            LOG.warn("Resource at location [{}] cannot be obtained (return null) from ServletContext !!!", finalLocation);
+        }
+    }
+
+    protected void sendStream(PrintWriter writer, InputStreamReader reader) throws IOException {
+        char[] buffer = new char[BUFFER_SIZE];
+        int charRead;
+        while((charRead = reader.read(buffer)) != -1) {
+            writer.write(buffer, 0, charRead);
+        }
+    }
+
+    protected String adjustLocation(String location) {
+        if (location.charAt(0) != '/') {
+            return "/" + location;
+        }
+        return location;
+    }
+
+    protected void applyAdditionalHeaders(HttpServletResponse response) {
+        response.setHeader("Content-Disposition", "inline");
+    }
+
+    protected void applyCharset(Charset charset, HttpServletResponse response) {
+        if (charset != null) {
+            response.setContentType("text/plain; charset=" + charSet);
+        } else {
+            response.setContentType("text/plain");
+        }
+    }
+
+    protected Charset readCharset() {
+        Charset charset = null;
+        if (charSet != null) {
+            if (Charset.isSupported(charSet)) {
+                charset = Charset.forName(charSet);
+            } else {
+                LOG.warn("charset [{}] is not recognized", charset);
+                charset = null;
+            }
+        }
+        return charset;
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/PostbackResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/PostbackResult.java b/core/src/main/java/org/apache/struts2/result/PostbackResult.java
new file mode 100644
index 0000000..ee14384
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/PostbackResult.java
@@ -0,0 +1,232 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.Map;
+
+/**
+ * <!-- START SNIPPET: description -->
+ * A result that renders the current request parameters as a form which
+ * immediately submits a <a href="http://en.wikipedia.org/wiki/Postback">postback</a>
+ * to the specified destination.
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>Parameters:</b>
+ * <!-- START SNIPPET: params -->
+ * <ul>
+ *     <li>location - http location to post the form</li>
+ *     <li>prependServletContext (true|false) -  when location is relative, controls if to add Servlet Context, default "true"</li>
+ *     <li>actionName - action name to post the form (resolved as an expression)</li>
+ *     <li>namespace - action's namespace to use (resolved as an expression)</li>
+ *     <li>method - actions' method to use (resolved as an expression)</li>
+ *     <li>cache (true|false) - when set to true adds cache control headers, default "true"</li>
+ *     <li>parse (true|false) - when set to true actionName, namespace and method are parsed, default "true"</li>
+ * </ul>
+ * <!-- END SNIPPET: params -->
+ * <p/>
+ * <b>Examples:</b>
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * &lt;action name="registerThirdParty" &gt;
+ *   &lt;result type="postback"&gt;https://www.example.com/register&lt;/result&gt;
+ * &lt;/action&gt;
+ *
+ * &lt;action name="registerThirdParty" &gt;
+ *   &lt;result type="postback"&gt;
+ *     &lt;param name="namespace"&gt;/secure&lt;/param&gt;
+ *     &lt;param name="actionName"&gt;register2&lt;/param&gt;
+ *   &lt;/result&gt;
+ * &lt;/action&gt;
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ */
+public class PostbackResult extends StrutsResultSupport {
+
+    private String actionName;
+    private String namespace;
+    private String method;
+    private boolean prependServletContext = true;
+    private boolean cache = true;
+
+    protected ActionMapper actionMapper;
+
+    @Override
+    protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+        ActionContext ctx = invocation.getInvocationContext();
+        HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+        HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);
+
+        // Cache?
+        if (!cache) {
+            response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // HTTP 1.1
+            response.setHeader("Pragma", "no-cache"); // HTTP 1.0
+            response.setDateHeader("Expires", 0); // Proxies
+        }
+
+        // Render
+        PrintWriter pw = new PrintWriter(response.getOutputStream());
+        pw.write("<!DOCTYPE html><html><body><form action=\"" + finalLocation + "\" method=\"POST\">");
+        writeFormElements(request, pw);
+        writePrologueScript(pw);
+        pw.write("</html>");
+        pw.flush();
+    }
+
+    @Override
+    public void execute(ActionInvocation invocation) throws Exception {
+        String postbackUri = makePostbackUri(invocation);
+        setLocation(postbackUri);
+        super.execute(invocation);
+    }
+
+    /**
+     * Determines if the specified form input element should be included.
+     *
+     * @param name the input element name
+     * @param values the input element values
+     * @return {@code true} if included; otherwise {@code false}
+     */
+    protected boolean isElementIncluded(String name, String[] values) {
+        return !name.startsWith("action:");
+    }
+
+    protected String makePostbackUri(ActionInvocation invocation) {
+        ActionContext ctx = invocation.getInvocationContext();
+        HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+        String postbackUri;
+
+        if (actionName != null) {
+            actionName = conditionalParse(actionName, invocation);
+            if (namespace == null) {
+                namespace = invocation.getProxy().getNamespace();
+            } else {
+                namespace = conditionalParse(namespace, invocation);
+            }
+            if (method == null) {
+                method = "";
+            } else {
+                method = conditionalParse(method, invocation);
+            }
+            postbackUri = request.getContextPath() + actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
+        } else {
+            String location = getLocation();
+            // Do not prepend if the URL is a FQN
+            if (!location.matches("^([a-zA-z]+:)?//.*")) {
+                // If the URL is relative to the servlet context, prepend the servlet context path
+                if (prependServletContext && (request.getContextPath() != null) && (request.getContextPath().length() > 0)) {
+                    location = request.getContextPath() + location;
+                }
+            }
+            postbackUri = location;
+        }
+
+        return postbackUri;
+    }
+
+    @Inject
+    public final void setActionMapper(ActionMapper mapper) {
+        this.actionMapper = mapper;
+    }
+
+    /**
+     * Sets the name of the destination action.
+     *
+     * @param actionName the action name
+     */
+    public final void setActionName(String actionName) {
+        this.actionName = actionName;
+    }
+
+    /**
+     * Stores the option to cache the rendered intermediate page. The default
+     * is {@code true}.
+     *
+     * @return {@code true} to cache; otherwise {@code false}
+     */
+    public final void setCache(boolean cache) {
+        this.cache = cache;
+    }
+
+    /**
+     * Sets the method of the destination action.
+     *
+     * @param method the method
+     */
+    public final void setMethod(String method) {
+        this.method = method;
+    }
+
+    /**
+     * Sets the namespace of the destination action.
+     *
+     * @param namespace the namespace
+     */
+    public final void setNamespace(String namespace) {
+        this.namespace = namespace;
+    }
+
+    public final void setPrependServletContext(boolean prependServletContext) {
+        this.prependServletContext = prependServletContext;
+    }
+
+    protected void writeFormElement(PrintWriter pw, String name, String[] values) throws UnsupportedEncodingException {
+        for (String value : values) {
+            String encName = URLEncoder.encode(name, "UTF-8");
+            String encValue = URLEncoder.encode(value, "UTF-8");
+            pw.write("<input type=\"hidden\" name=\"" + encName + "\" value=\"" + encValue + "\"/>");
+        }
+    }
+
+    private void writeFormElements(HttpServletRequest request, PrintWriter pw) throws UnsupportedEncodingException {
+        Map<String, String[]> params = request.getParameterMap();
+        for (String name : params.keySet()) {
+            String[] values = params.get(name);
+            if (isElementIncluded(name, values)) {
+                writeFormElement(pw, name, values);
+            }
+        }
+    }
+
+    /**
+     * Outputs the script after the form has been emitted. The default script
+     * is to submit the form using a JavaScript time out that immediately expires.
+     *
+     * @param pw the print writer
+     */
+    protected void writePrologueScript(PrintWriter pw) {
+        pw.write("<script>");
+        pw.write("setTimeout(function(){document.forms[0].submit();},0);");
+        pw.write("</script>");
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java b/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
new file mode 100644
index 0000000..2d12606
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
@@ -0,0 +1,227 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.util.reflection.ReflectionExceptionHandler;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * This result uses the {@link ActionMapper} provided by the
+ * {@link ActionMapperFactory} to redirect the browser to a URL that invokes the
+ * specified action and (optional) namespace. This is better than the
+ * {@link ServletRedirectResult} because it does not require you to encode the
+ * URL patterns processed by the {@link ActionMapper} in to your struts.xml
+ * configuration files. This means you can change your URL patterns at any point
+ * and your application will still work. It is strongly recommended that if you
+ * are redirecting to another action, you use this result rather than the
+ * standard redirect result.
+ *
+ * See examples below for an example of how request parameters could be passed
+ * in.
+ *
+ * <!-- END SNIPPET: description -->
+ *
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>actionName (default)</b> - The name of the action that will be
+ * redirected to.</li>
+ *
+ * <li><b>namespace</b> - Used to determine which namespace the action is in
+ * that we're redirecting to.  If namespace is null, the default will be the
+ * current namespace.</li>
+ *
+ * <li><b>suppressEmptyParameters</b> - Optional boolean (defaults to false) that
+ * can prevent parameters with no values from being included in the redirect
+ * URL.</li>
+ *
+ * <li><b>parse</b> - Boolean, true by default.  If set to false, the actionName
+ * param will not be parsed for Ognl expressions.</li>
+ *
+ * <li><b>anchor</b> - Optional.  Also known as "fragment" or colloquially as
+ * "hash".  You can specify an anchor for a result.</li>
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * &lt;package name="public" extends="struts-default"&gt;
+ *     &lt;action name="login" class="..."&gt;
+ *         &lt;!-- Redirect to another namespace --&gt;
+ *         &lt;result type="redirectAction"&gt;
+ *             &lt;param name="actionName"&gt;dashboard&lt;/param&gt;
+ *             &lt;param name="namespace"&gt;/secure&lt;/param&gt;
+ *         &lt;/result&gt;
+ *     &lt;/action&gt;
+ * &lt;/package&gt;
+ *
+ * &lt;package name="secure" extends="struts-default" namespace="/secure"&gt;
+ *     &lt;-- Redirect to an action in the same namespace --&gt;
+ *     &lt;action name="dashboard" class="..."&gt;
+ *         &lt;result&gt;dashboard.jsp&lt;/result&gt;
+ *         &lt;result name="error" type="redirectAction"&gt;error&lt;/result&gt;
+ *     &lt;/action&gt;
+ *
+ *     &lt;action name="error" class="..."&gt;
+ *         &lt;result&gt;error.jsp&lt;/result&gt;
+ *     &lt;/action&gt;
+ * &lt;/package&gt;
+ *
+ * &lt;package name="passingRequestParameters" extends="struts-default" namespace="/passingRequestParameters"&gt;
+ *    &lt;!-- Pass parameters (reportType, width and height) --&gt;
+ *    &lt;!--
+ *    The redirectAction url generated will be :
+ *    /genReport/generateReport.action?reportType=pie&width=100&height=100#summary
+ *    --&gt;
+ *    &lt;action name="gatherReportInfo" class="..."&gt;
+ *       &lt;result name="showReportResult" type="redirectAction"&gt;
+ *          &lt;param name="actionName"&gt;generateReport&lt;/param&gt;
+ *          &lt;param name="namespace"&gt;/genReport&lt;/param&gt;
+ *          &lt;param name="reportType"&gt;pie&lt;/param&gt;
+ *          &lt;param name="width"&gt;100&lt;/param&gt;
+ *          &lt;param name="height"&gt;100&lt;/param&gt;
+ *          &lt;param name="empty"&gt;&lt;/param&gt;
+ *          &lt;param name="suppressEmptyParameters"&gt;true&lt;/param&gt;
+ *          &lt;param name="anchor"&gt;summary&lt;/param&gt;
+ *       &lt;/result&gt;
+ *    &lt;/action&gt;
+ * &lt;/package&gt;
+ *
+ *
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ *
+ * @see ActionMapper
+ */
+public class ServletActionRedirectResult extends ServletRedirectResult implements ReflectionExceptionHandler {
+
+    private static final long serialVersionUID = -9042425229314584066L;
+
+    /* The default parameter */
+    public static final String DEFAULT_PARAM = "actionName";
+
+    protected String actionName;
+    protected String namespace;
+    protected String method;
+
+    public ServletActionRedirectResult() {
+        super();
+    }
+
+    public ServletActionRedirectResult(String actionName) {
+        this(null, actionName, null, null);
+    }
+
+    public ServletActionRedirectResult(String actionName, String method) {
+        this(null, actionName, method, null);
+    }
+
+    public ServletActionRedirectResult(String namespace, String actionName, String method) {
+        this(namespace, actionName, method, null);
+    }
+
+    public ServletActionRedirectResult(String namespace, String actionName, String method, String anchor) {
+        super(null, anchor);
+        this.namespace = namespace;
+        this.actionName = actionName;
+        this.method = method;
+    }
+
+    /**
+     * @see com.opensymphony.xwork2.Result#execute(com.opensymphony.xwork2.ActionInvocation)
+     */
+    public void execute(ActionInvocation invocation) throws Exception {
+        actionName = conditionalParse(actionName, invocation);
+        if (namespace == null) {
+            namespace = invocation.getProxy().getNamespace();
+        } else {
+            namespace = conditionalParse(namespace, invocation);
+        }
+        if (method == null) {
+            method = "";
+        } else {
+            method = conditionalParse(method, invocation);
+        }
+
+        String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
+
+        setLocation(tmpLocation);
+
+        super.execute(invocation);
+    }
+
+    /**
+     * Sets the action name
+     *
+     * @param actionName The name
+     */
+    public void setActionName(String actionName) {
+        this.actionName = actionName;
+    }
+
+    /**
+     * Sets the namespace
+     *
+     * @param namespace The namespace
+     */
+    public void setNamespace(String namespace) {
+        this.namespace = namespace;
+    }
+
+    /**
+     * Sets the method
+     *
+     * @param method The method
+     */
+    public void setMethod(String method) {
+        this.method = method;
+    }
+
+    protected List<String> getProhibitedResultParams() {
+        return Arrays.asList(
+                DEFAULT_PARAM,
+                "namespace",
+                "method",
+                "encode",
+                "parse",
+                "location",
+                "prependServletContext",
+                "suppressEmptyParameters",
+                "anchor",
+                "statusCode"
+        );
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java b/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
new file mode 100644
index 0000000..8d20e99
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
@@ -0,0 +1,174 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.StrutsStatics;
+import org.apache.struts2.views.util.UrlHelper;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.jsp.PageContext;
+import java.util.Map;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * Includes or forwards to a view (usually a jsp). Behind the scenes Struts
+ * will use a RequestDispatcher, where the target servlet/JSP receives the same
+ * request/response objects as the original servlet/JSP. Therefore, you can pass
+ * data between them using request.setAttribute() - the Struts action is
+ * available.
+ * <p/>
+ * There are three possible ways the result can be executed:
+ *
+ * <ul>
+ *
+ * <li>If we are in the scope of a JSP (a PageContext is available), PageContext's
+ * {@link PageContext#include(String) include} method is called.</li>
+ *
+ * <li>If there is no PageContext and we're not in any sort of include (there is no
+ * "javax.servlet.include.servlet_path" in the request attributes), then a call to
+ * {@link RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse) forward}
+ * is made.</li>
+ *
+ * <li>Otherwise, {@link RequestDispatcher#include(javax.servlet.ServletRequest, javax.servlet.ServletResponse) include}
+ * is called.</li>
+ *
+ * </ul>
+ * <!-- END SNIPPET: description -->
+ *
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>location (default)</b> - the location to go to after execution (ex. jsp).</li>
+ *
+ * <li><b>parse</b> - true by default. If set to false, the location param will not be parsed for Ognl expressions.</li>
+ *
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * &lt;result name="success" type="dispatcher"&gt;
+ *   &lt;param name="location"&gt;foo.jsp&lt;/param&gt;
+ * &lt;/result&gt;
+ * <!-- END SNIPPET: example --></pre>
+ *
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ *
+ * @see javax.servlet.RequestDispatcher
+ */
+public class ServletDispatcherResult extends StrutsResultSupport {
+
+    private static final long serialVersionUID = -1970659272360685627L;
+
+    private static final Logger LOG = LogManager.getLogger(ServletDispatcherResult.class);
+
+    private UrlHelper urlHelper;
+
+    public ServletDispatcherResult() {
+        super();
+    }
+
+    public ServletDispatcherResult(String location) {
+        super(location);
+    }
+
+    @Inject
+    public void setUrlHelper(UrlHelper urlHelper) {
+        this.urlHelper = urlHelper;
+    }
+
+    /**
+     * Dispatches to the given location. Does its forward via a RequestDispatcher. If the
+     * dispatch fails a 404 error will be sent back in the http response.
+     *
+     * @param finalLocation the location to dispatch to.
+     * @param invocation    the execution state of the action
+     * @throws Exception if an error occurs. If the dispatch fails the error will go back via the
+     *                   HTTP request.
+     */
+    public void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+        LOG.debug("Forwarding to location: {}", finalLocation);
+
+        PageContext pageContext = ServletActionContext.getPageContext();
+
+        if (pageContext != null) {
+            pageContext.include(finalLocation);
+        } else {
+            HttpServletRequest request = ServletActionContext.getRequest();
+            HttpServletResponse response = ServletActionContext.getResponse();
+            RequestDispatcher dispatcher = request.getRequestDispatcher(finalLocation);
+
+            //add parameters passed on the location to #parameters
+            // see WW-2120
+            if (StringUtils.isNotEmpty(finalLocation) && finalLocation.indexOf("?") > 0) {
+                String queryString = finalLocation.substring(finalLocation.indexOf("?") + 1);
+                Map<String, Object> parameters = getParameters(invocation);
+                Map<String, Object> queryParams = urlHelper.parseQueryString(queryString, true);
+                if (queryParams != null && !queryParams.isEmpty())
+                    parameters.putAll(queryParams);
+            }
+
+            // if the view doesn't exist, let's do a 404
+            if (dispatcher == null) {
+                response.sendError(404, "result '" + finalLocation + "' not found");
+                return;
+            }
+
+            //if we are inside an action tag, we always need to do an include
+            Boolean insideActionTag = (Boolean) ObjectUtils.defaultIfNull(request.getAttribute(StrutsStatics.STRUTS_ACTION_TAG_INVOCATION), Boolean.FALSE);
+
+            // If we're included, then include the view
+            // Otherwise do forward
+            // This allow the page to, for example, set content type
+            if (!insideActionTag && !response.isCommitted() && (request.getAttribute("javax.servlet.include.servlet_path") == null)) {
+                request.setAttribute("struts.view_uri", finalLocation);
+                request.setAttribute("struts.request_uri", request.getRequestURI());
+
+                dispatcher.forward(request, response);
+            } else {
+                dispatcher.include(request, response);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> getParameters(ActionInvocation invocation) {
+        return (Map<String, Object>) invocation.getInvocationContext().getContextMap().get("parameters");
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java b/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
new file mode 100644
index 0000000..c3fe70b
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
@@ -0,0 +1,323 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.config.entities.ResultConfig;
+import com.opensymphony.xwork2.inject.Inject;
+import com.opensymphony.xwork2.util.reflection.ReflectionException;
+import com.opensymphony.xwork2.util.reflection.ReflectionExceptionHandler;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.dispatcher.Dispatcher;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+import org.apache.struts2.views.util.UrlHelper;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.util.*;
+
+import static javax.servlet.http.HttpServletResponse.SC_FOUND;
+
+/**
+ * <!-- START SNIPPET: description -->
+ * 
+ * Calls the {@link HttpServletResponse#sendRedirect(String) sendRedirect}
+ * method to the location specified. The response is told to redirect the
+ * browser to the specified location (a new request from the client). The
+ * consequence of doing this means that the action (action instance, action
+ * errors, field errors, etc) that was just executed is lost and no longer
+ * available. This is because actions are built on a single-thread model. The
+ * only way to pass data is through the session or with web parameters
+ * (url?name=value) which can be OGNL expressions.
+ * 
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ * 
+ * <!-- START SNIPPET: params -->
+ * 
+ * <ul>
+ * 
+ * <li><b>location (default)</b> - the location to go to after execution.</li>
+ * 
+ * <li><b>parse</b> - true by default. If set to false, the location param will
+ * not be parsed for Ognl expressions.</li>
+ * 
+ * <li><b>anchor</b> - Optional.  Also known as "fragment" or colloquially as 
+ * "hash".  You can specify an anchor for a result.</li>
+ * </ul>
+ * 
+ * <p>
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ * </p>
+ * 
+ * <!-- END SNIPPET: params -->
+ * 
+ * <b>Example:</b>
+ * 
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * &lt;!--
+ *   The redirect URL generated will be:
+ *   /foo.jsp#FRAGMENT
+ * --&gt;
+ * &lt;result name="success" type="redirect"&gt;
+ *   &lt;param name="location"&gt;foo.jsp&lt;/param&gt;
+ *   &lt;param name="parse"&gt;false&lt;/param&gt;
+ *   &lt;param name="anchor"&gt;FRAGMENT&lt;/param&gt;
+ * &lt;/result&gt;
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ * 
+ */
+public class ServletRedirectResult extends StrutsResultSupport implements ReflectionExceptionHandler {
+
+    private static final long serialVersionUID = 6316947346435301270L;
+
+    private static final Logger LOG = LogManager.getLogger(ServletRedirectResult.class);
+
+    protected boolean prependServletContext = true;
+    protected ActionMapper actionMapper;
+    protected int statusCode = SC_FOUND;
+    protected boolean suppressEmptyParameters = false;
+    protected Map<String, Object> requestParameters = new LinkedHashMap<>();
+    protected String anchor;
+
+    private UrlHelper urlHelper;
+
+    public ServletRedirectResult() {
+        super();
+    }
+
+    public ServletRedirectResult(String location) {
+        this(location, null);
+    }
+
+    public ServletRedirectResult(String location, String anchor) {
+        super(location);
+        this.anchor = anchor;
+    }
+
+    @Inject
+    public void setActionMapper(ActionMapper mapper) {
+        this.actionMapper = mapper;
+    }
+
+    @Inject
+    public void setUrlHelper(UrlHelper urlHelper) {
+        this.urlHelper = urlHelper;
+    }
+
+    public void setStatusCode(int code) {
+        this.statusCode = code;
+    }
+
+    /**
+     * Set the optional anchor value.
+     * 
+     * @param anchor
+     */
+    public void setAnchor(String anchor) {
+        this.anchor = anchor;
+    }
+
+    /**
+     * Sets whether or not to prepend the servlet context path to the redirected
+     * URL.
+     * 
+     * @param prependServletContext <tt>true</tt> to prepend the location with the servlet context path, <tt>false</tt> otherwise.
+     */
+    public void setPrependServletContext(boolean prependServletContext) {
+        this.prependServletContext = prependServletContext;
+    }
+
+    public void execute(ActionInvocation invocation) throws Exception {
+        if (anchor != null) {
+            anchor = conditionalParse(anchor, invocation);
+        }
+        super.execute(invocation);
+    }
+
+    /**
+     * Redirects to the location specified by calling
+     * {@link HttpServletResponse#sendRedirect(String)}.
+     * 
+     * @param finalLocation the location to redirect to.
+     * @param invocation an encapsulation of the action execution state.
+     * @throws Exception if an error occurs when redirecting.
+     */
+    protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+        ActionContext ctx = invocation.getInvocationContext();
+        HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+        HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);
+
+        if (isPathUrl(finalLocation)) {
+            if (!finalLocation.startsWith("/")) {
+                ActionMapping mapping = actionMapper.getMapping(request, Dispatcher.getInstance().getConfigurationManager());
+                String namespace = null;
+                if (mapping != null) {
+                    namespace = mapping.getNamespace();
+                }
+
+                if ((namespace != null) && (namespace.length() > 0) && (!"/".equals(namespace))) {
+                    finalLocation = namespace + "/" + finalLocation;
+                } else {
+                    finalLocation = "/" + finalLocation;
+                }
+            }
+
+            // if the URL's are relative to the servlet context, append the servlet context path
+            if (prependServletContext && (request.getContextPath() != null) && (request.getContextPath().length() > 0)) {
+                finalLocation = request.getContextPath() + finalLocation;
+            }
+        }
+        ResultConfig resultConfig = invocation.getProxy().getConfig().getResults().get(invocation.getResultCode());
+        if (resultConfig != null) {
+            Map<String, String> resultConfigParams = resultConfig.getParams();
+
+            List<String> prohibitedResultParams = getProhibitedResultParams();
+            for (Map.Entry<String, String> e : resultConfigParams.entrySet()) {
+                if (!prohibitedResultParams.contains(e.getKey())) {
+                    Collection<String> values = conditionalParseCollection(e.getValue(), invocation, suppressEmptyParameters);
+                    if (!suppressEmptyParameters || !values.isEmpty()) {
+                        requestParameters.put(e.getKey(), values);
+                    }
+                }
+            }
+        }
+
+        StringBuilder tmpLocation = new StringBuilder(finalLocation);
+        urlHelper.buildParametersString(requestParameters, tmpLocation, "&");
+
+        // add the anchor
+        if (anchor != null) {
+            tmpLocation.append('#').append(anchor);
+        }
+
+        finalLocation = response.encodeRedirectURL(tmpLocation.toString());
+
+        LOG.debug("Redirecting to finalLocation: {}", finalLocation);
+
+        sendRedirect(response, finalLocation);
+    }
+
+    protected List<String> getProhibitedResultParams() {
+        return Arrays.asList(
+                DEFAULT_PARAM,
+                "namespace",
+                "method",
+                "encode",
+                "parse",
+                "location",
+                "prependServletContext",
+                "suppressEmptyParameters",
+                "anchor",
+                "statusCode"
+        );
+    }
+
+    /**
+     * Sends the redirection. Can be overridden to customize how the redirect is
+     * handled (i.e. to use a different status code)
+     * 
+     * @param response The response
+     * @param finalLocation The location URI
+     * @throws IOException
+     */
+    protected void sendRedirect(HttpServletResponse response, String finalLocation) throws IOException {
+        if (SC_FOUND == statusCode) {
+            response.sendRedirect(finalLocation);
+        } else {
+            response.setStatus(statusCode);
+            response.setHeader("Location", finalLocation);
+            response.getWriter().write(finalLocation);
+            response.getWriter().close();
+        }
+
+    }
+
+    /**
+     * Checks if url is simple path or either full url
+     *
+     * @param url string
+     * @return true if it's just a path not a full url
+     */
+    protected boolean isPathUrl(String url) {
+        try {
+            String rawUrl = url;
+            if (url.contains("?")) {
+                rawUrl = url.substring(0, url.indexOf("?"));
+            }
+            URI uri = URI.create(rawUrl.replaceAll(" ", "%20"));
+            if (uri.isAbsolute()) {
+                URL validUrl = uri.toURL();
+                LOG.debug("[{}] is full url, not a path", url);
+                return validUrl.getProtocol() == null;
+            } else {
+                LOG.debug("[{}] isn't absolute URI, assuming it's a path", url);
+                return true;
+            }
+        } catch (IllegalArgumentException e) {
+            LOG.debug("[{}] isn't a valid URL, assuming it's a path", url, e);
+            return true;
+        } catch (MalformedURLException e) {
+            LOG.debug("[{}] isn't a valid URL, assuming it's a path", url, e);
+            return true;
+        }
+    }
+
+    /**
+     * Sets the suppressEmptyParameters option
+     * 
+     * @param suppressEmptyParameters The new value for this option
+     */
+    public void setSuppressEmptyParameters(boolean suppressEmptyParameters) {
+        this.suppressEmptyParameters = suppressEmptyParameters;
+    }
+
+    /**
+     * Adds a request parameter to be added to the redirect url
+     * 
+     * @param key The parameter name
+     * @param value The parameter value
+     */
+    public ServletRedirectResult addParameter(String key, Object value) {
+        requestParameters.put(key, String.valueOf(value));
+        return this;
+    }
+
+    public void handle(ReflectionException ex) {
+        // Only log as debug as they are probably parameters to be appended to the url
+        if (LOG.isDebugEnabled()) {
+            LOG.debug(ex.getMessage(), ex);
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/StreamResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/StreamResult.java b/core/src/main/java/org/apache/struts2/result/StreamResult.java
new file mode 100644
index 0000000..5574cc1
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/StreamResult.java
@@ -0,0 +1,329 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * A custom Result type for sending raw data (via an InputStream) directly to the
+ * HttpServletResponse. Very useful for allowing users to download content.
+ *
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>contentType</b> - the stream mime-type as sent to the web browser
+ * (default = <code>text/plain</code>).</li>
+ *
+ * <li><b>contentLength</b> - the stream length in bytes (the browser displays a
+ * progress bar).</li>
+ *
+ * <li><b>contentDisposition</b> - the content disposition header value for
+ * specifing the file name (default = <code>inline</code>, values are typically
+ * <i>attachment;filename="document.pdf"</i>.</li>
+ *
+ * <li><b>inputName</b> - the name of the InputStream property from the chained
+ * action (default = <code>inputStream</code>).</li>
+ *
+ * <li><b>bufferSize</b> - the size of the buffer to copy from input to output
+ * (default = <code>1024</code>).</li>
+ *
+ * <li><b>allowCaching</b> if set to 'false' it will set the headers 'Pragma' and 'Cache-Control'
+ * to 'no-cahce', and prevent client from caching the content. (default = <code>true</code>)
+ *
+ * <li><b>contentCharSet</b> if set to a string, ';charset=value' will be added to the
+ * content-type header, where value is the string set. If set to an expression, the result
+ * of evaluating the expression will be used. If not set, then no charset will be set on
+ * the header</li>
+ * </ul>
+ * 
+ * <p>These parameters can also be set by exposing a similarly named getter method on your Action.  For example, you can
+ * provide <code>getContentType()</code> to override that parameter for the current action.</p>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * &lt;result name="success" type="stream"&gt;
+ *   &lt;param name="contentType"&gt;image/jpeg&lt;/param&gt;
+ *   &lt;param name="inputName"&gt;imageStream&lt;/param&gt;
+ *   &lt;param name="contentDisposition"&gt;attachment;filename="document.pdf"&lt;/param&gt;
+ *   &lt;param name="bufferSize"&gt;1024&lt;/param&gt;
+ * &lt;/result&gt;
+ * <!-- END SNIPPET: example --></pre>
+ *
+ */
+public class StreamResult extends StrutsResultSupport {
+
+    private static final long serialVersionUID = -1468409635999059850L;
+
+    protected static final Logger LOG = LogManager.getLogger(StreamResult.class);
+
+    public static final String DEFAULT_PARAM = "inputName";
+
+    protected String contentType = "text/plain";
+    protected String contentLength;
+    protected String contentDisposition = "inline";
+    protected String contentCharSet ;
+    protected String inputName = "inputStream";
+    protected InputStream inputStream;
+    protected int bufferSize = 1024;
+    protected boolean allowCaching = true;
+
+    public StreamResult() {
+        super();
+    }
+
+    public StreamResult(InputStream in) {
+        this.inputStream = in;
+    }
+
+     /**
+     * @return Returns the whether or not the client should be requested to allow caching of the data stream.
+     */
+    public boolean getAllowCaching() {
+        return allowCaching;
+    }
+
+    /**
+     * Set allowCaching to <tt>false</tt> to indicate that the client should be requested not to cache the data stream.
+     * This is set to <tt>false</tt> by default
+     *
+     * @param allowCaching Enable caching.
+     */
+    public void setAllowCaching(boolean allowCaching) {
+        this.allowCaching = allowCaching;
+    }
+
+
+    /**
+     * @return Returns the bufferSize.
+     */
+    public int getBufferSize() {
+        return (bufferSize);
+    }
+
+    /**
+     * @param bufferSize The bufferSize to set.
+     */
+    public void setBufferSize(int bufferSize) {
+        this.bufferSize = bufferSize;
+    }
+
+    /**
+     * @return Returns the contentType.
+     */
+    public String getContentType() {
+        return (contentType);
+    }
+
+    /**
+     * @param contentType The contentType to set.
+     */
+    public void setContentType(String contentType) {
+        this.contentType = contentType;
+    }
+
+    /**
+     * @return Returns the contentLength.
+     */
+    public String getContentLength() {
+        return contentLength;
+    }
+
+    /**
+     * @param contentLength The contentLength to set.
+     */
+    public void setContentLength(String contentLength) {
+        this.contentLength = contentLength;
+    }
+
+    /**
+     * @return Returns the Content-disposition header value.
+     */
+    public String getContentDisposition() {
+        return contentDisposition;
+    }
+
+    /**
+     * @param contentDisposition the Content-disposition header value to use.
+     */
+    public void setContentDisposition(String contentDisposition) {
+        this.contentDisposition = contentDisposition;
+    }
+
+    /**
+     * @return Returns the charset specified by the user
+     */
+    public String getContentCharSet() {
+        return contentCharSet;
+    }
+
+    /**
+     * @param contentCharSet the charset to use on the header when sending the stream
+     */
+    public void setContentCharSet(String contentCharSet) {
+        this.contentCharSet = contentCharSet;
+    }
+
+    /**
+     * @return Returns the inputName.
+     */
+    public String getInputName() {
+        return (inputName);
+    }
+
+    /**
+     * @param inputName The inputName to set.
+     */
+    public void setInputName(String inputName) {
+        this.inputName = inputName;
+    }
+
+    /**
+     * @see StrutsResultSupport#doExecute(java.lang.String, com.opensymphony.xwork2.ActionInvocation)
+     */
+    protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+
+        // Override any parameters using values on the stack
+        resolveParamsFromStack(invocation.getStack(), invocation);
+
+        // Find the Response in context
+        HttpServletResponse oResponse = (HttpServletResponse) invocation.getInvocationContext().get(HTTP_RESPONSE);
+        try (OutputStream oOutput = oResponse.getOutputStream()) {
+            if (inputStream == null) {
+                // Find the inputstream from the invocation variable stack
+                inputStream = (InputStream) invocation.getStack().findValue(conditionalParse(inputName, invocation));
+            }
+
+            if (inputStream == null) {
+                String msg = ("Can not find a java.io.InputStream with the name [" + inputName + "] in the invocation stack. " +
+                    "Check the <param name=\"inputName\"> tag specified for this action.");
+                LOG.error(msg);
+                throw new IllegalArgumentException(msg);
+            }
+
+            // Set the content type
+            if (contentCharSet != null && ! contentCharSet.equals("")) {
+                oResponse.setContentType(conditionalParse(contentType, invocation)+";charset="+contentCharSet);
+            }
+            else {
+                oResponse.setContentType(conditionalParse(contentType, invocation));
+            }
+
+            // Set the content length
+            if (contentLength != null) {
+                String _contentLength = conditionalParse(contentLength, invocation);
+                int _contentLengthAsInt = -1;
+                try {
+                    _contentLengthAsInt = Integer.parseInt(_contentLength);
+                    if (_contentLengthAsInt >= 0) {
+                        oResponse.setContentLength(_contentLengthAsInt);
+                    }
+                }
+                catch(NumberFormatException e) {
+                    LOG.warn("failed to recognize {} as a number, contentLength header will not be set", _contentLength, e);
+                }
+            }
+
+            // Set the content-disposition
+            if (contentDisposition != null) {
+                oResponse.addHeader("Content-Disposition", conditionalParse(contentDisposition, invocation));
+            }
+
+            // Set the cache control headers if neccessary
+            if (!allowCaching) {
+                oResponse.addHeader("Pragma", "no-cache");
+                oResponse.addHeader("Cache-Control", "no-cache");
+            }
+
+            LOG.debug("Streaming result [{}] type=[{}] length=[{}] content-disposition=[{}] charset=[{}]",
+                    inputName, contentType, contentLength, contentDisposition, contentCharSet);
+
+            // Copy input to output
+        	LOG.debug("Streaming to output buffer +++ START +++");
+            byte[] oBuff = new byte[bufferSize];
+            int iSize;
+            while (-1 != (iSize = inputStream.read(oBuff))) {
+                oOutput.write(oBuff, 0, iSize);
+            }
+        	LOG.debug("Streaming to output buffer +++ END +++");
+
+            // Flush
+            oOutput.flush();
+        }
+    }
+
+    /**
+     * Tries to lookup the parameters on the stack.  Will override any existing parameters
+     *
+     * @param stack The current value stack
+     */
+    protected void resolveParamsFromStack(ValueStack stack, ActionInvocation invocation) {
+        String disposition = stack.findString("contentDisposition");
+        if (disposition != null) {
+            setContentDisposition(disposition);
+        }
+
+        String contentType = stack.findString("contentType");
+        if (contentType != null) {
+            setContentType(contentType);
+        }
+
+        String inputName = stack.findString("inputName");
+        if (inputName != null) {
+            setInputName(inputName);
+        }
+
+        String contentLength = stack.findString("contentLength");
+        if (contentLength != null) {
+            setContentLength(contentLength);
+        }
+
+        Integer bufferSize = (Integer) stack.findValue("bufferSize", Integer.class);
+        if (bufferSize != null) {
+            setBufferSize(bufferSize);
+        }
+
+        if (contentCharSet != null ) {
+            contentCharSet = conditionalParse(contentCharSet, invocation);
+        }
+        else {
+            contentCharSet = stack.findString("contentCharSet");
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java b/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
new file mode 100644
index 0000000..bdb1b93
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
@@ -0,0 +1,266 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.Result;
+import com.opensymphony.xwork2.util.TextParseUtil;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.StrutsStatics;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collection;
+
+
+/**
+ * <!-- START SNIPPET: javadoc -->
+ *
+ * A base class for all Struts action execution results.
+ * The "location" param is the default parameter, meaning the most common usage of this result would be:
+ * <p/>
+ * This class provides two common parameters for any subclass:
+ * <ul>
+ * <li>location - the location to go to after execution (could be a jsp page or another action).
+ * It can be parsed as per the rules definied in the
+ * {@link TextParseUtil#translateVariables(java.lang.String, com.opensymphony.xwork2.util.ValueStack) translateVariables}
+ * method</li>
+ * <li>parse - true by default. If set to false, the location param will not be parsed for expressions</li>
+ * <li>encode - false by default. If set to false, the location param will not be url encoded. This only have effect when parse is true</li>
+ * </ul>
+ *
+ * <b>NOTE:</b>
+ * The encode param will only have effect when parse is true
+ *
+ * <!-- END SNIPPET: javadoc -->
+ *
+ * <p/>
+ *
+ * <!-- START SNIPPET: example -->
+ *
+ * <p/>
+ * In the struts.xml configuration file, these would be included as:
+ * <p/>
+ * <pre>
+ *  &lt;result name="success" type="redirect"&gt;
+ *      &lt;param name="<b>location</b>"&gt;foo.jsp&lt;/param&gt;
+ *  &lt;/result&gt;</pre>
+ * <p/>
+ * or
+ * <p/>
+ * <pre>
+ *  &lt;result name="success" type="redirect" &gt;
+ *      &lt;param name="<b>location</b>"&gt;foo.jsp?url=${myUrl}&lt;/param&gt;
+ *      &lt;param name="<b>parse</b>"&gt;true&lt;/param&gt;
+ *      &lt;param name="<b>encode</b>"&gt;true&lt;/param&gt;
+ *  &lt;/result&gt;</pre>
+ * <p/>
+ * In the above case, myUrl will be parsed against Ognl Value Stack and then
+ * URL encoded.
+ * <p/>
+ * or when using the default parameter feature
+ * <p/>
+ * <pre>
+ *  &lt;result name="success" type="redirect"&gt;<b>foo.jsp</b>&lt;/result&gt;</pre>
+ * <p/>
+ * You should subclass this class if you're interested in adding more parameters or functionality
+ * to your Result. If you do subclass this class you will need to
+ * override {@link #doExecute(String, ActionInvocation)}.<p>
+ * <p/>
+ * Any custom result can be defined in struts.xml as:
+ * <p/>
+ * <pre>
+ *  &lt;result-types&gt;
+ *      ...
+ *      &lt;result-type name="myresult" class="com.foo.MyResult" /&gt;
+ *  &lt;/result-types&gt;</pre>
+ * <p/>
+ * Please see the {@link com.opensymphony.xwork2.Result} class for more info on Results in general.
+ *
+ * <!-- END SNIPPET: example -->
+ *
+ * @see com.opensymphony.xwork2.Result
+ */
+public abstract class StrutsResultSupport implements Result, StrutsStatics {
+
+    private static final Logger LOG = LogManager.getLogger(StrutsResultSupport.class);
+
+    /** The default parameter */
+    public static final String DEFAULT_PARAM = "location";
+
+    /** use UTF-8 as this is the recommended encoding by W3C to avoid incompatibilities. */
+    public static final String DEFAULT_URL_ENCODING = "UTF-8";
+
+    private boolean parse;
+    private boolean encode;
+    private String location;
+    private String lastFinalLocation;
+
+    public StrutsResultSupport() {
+        this(null, true, false);
+    }
+
+    public StrutsResultSupport(String location) {
+        this(location, true, false);
+    }
+
+    public StrutsResultSupport(String location, boolean parse, boolean encode) {
+        this.location = location;
+        this.parse = parse;
+        this.encode = encode;
+    }
+
+    /**
+     * The location to go to after action execution. This could be a JSP page or another action.
+     * The location can contain OGNL expressions which will be evaulated if the <tt>parse</tt>
+     * parameter is set to <tt>true</tt>.
+     *
+     * @param location the location to go to after action execution.
+     * @see #setParse(boolean)
+     */
+    public void setLocation(String location) {
+        this.location = location;
+    }
+    
+    /**
+     * Gets the location it was created with, mainly for testing
+     */
+    public String getLocation() {
+        return location;
+    }
+
+    /**
+     * Returns the last parsed and encoded location value
+     */
+    public String getLastFinalLocation() {
+        return lastFinalLocation;
+    }
+
+    /**
+     * Set parse to <tt>true</tt> to indicate that the location should be parsed as an OGNL expression. This
+     * is set to <tt>true</tt> by default.
+     *
+     * @param parse <tt>true</tt> if the location parameter is an OGNL expression, <tt>false</tt> otherwise.
+     */
+    public void setParse(boolean parse) {
+        this.parse = parse;
+    }
+
+    /**
+     * Set encode to <tt>true</tt> to indicate that the location should be url encoded. This is set to
+     * <tt>true</tt> by default
+     *
+     * @param encode <tt>true</tt> if the location parameter should be url encode, <tt>false</tt> otherwise.
+     */
+    public void setEncode(boolean encode) {
+        this.encode = encode;
+    }
+
+    /**
+     * Implementation of the <tt>execute</tt> method from the <tt>Result</tt> interface. This will call
+     * the abstract method {@link #doExecute(String, ActionInvocation)} after optionally evaluating the
+     * location as an OGNL evaluation.
+     *
+     * @param invocation the execution state of the action.
+     * @throws Exception if an error occurs while executing the result.
+     */
+    public void execute(ActionInvocation invocation) throws Exception {
+        lastFinalLocation = conditionalParse(location, invocation);
+        doExecute(lastFinalLocation, invocation);
+    }
+
+    /**
+     * Parses the parameter for OGNL expressions against the valuestack
+     *
+     * @param param The parameter value
+     * @param invocation The action invocation instance
+     * @return The resulting string
+     */
+    protected String conditionalParse(String param, ActionInvocation invocation) {
+        if (parse && param != null && invocation != null) {
+            return TextParseUtil.translateVariables(
+                param, 
+                invocation.getStack(),
+                new EncodingParsedValueEvaluator());
+        } else {
+            return param;
+        }
+    }
+
+    /**
+     * As {@link #conditionalParse(String, ActionInvocation)} but does not
+     * convert found object into String. If found object is a collection it is
+     * returned if found object is not a collection it is wrapped in one.
+     * 
+     * @param param
+     * @param invocation
+     * @param excludeEmptyElements
+     * @return
+     */
+    protected Collection<String> conditionalParseCollection(String param, ActionInvocation invocation, boolean excludeEmptyElements) {
+        if (parse && param != null && invocation != null) {
+            return TextParseUtil.translateVariablesCollection(
+                param, 
+                invocation.getStack(),
+                excludeEmptyElements,
+                new EncodingParsedValueEvaluator());
+        } else {
+            Collection<String> collection = new ArrayList<>(1);
+            collection.add(param);
+            return collection;
+        }
+    }
+
+    /**
+     * {@link com.opensymphony.xwork2.util.TextParseUtil.ParsedValueEvaluator} to do URL encoding for found values. To be
+     * used for single strings or collections.
+     * 
+     */
+    private final class EncodingParsedValueEvaluator implements TextParseUtil.ParsedValueEvaluator {
+        public Object evaluate(String parsedValue) {
+            if (encode) {
+                if (parsedValue != null) {
+                    try {
+                        return URLEncoder.encode(parsedValue, DEFAULT_URL_ENCODING);
+                    }
+                    catch(UnsupportedEncodingException e) {
+                        LOG.warn("error while trying to encode [{}]", parsedValue, e);
+                    }
+                }
+            }
+            return parsedValue;
+        }
+    }
+
+    /**
+     * Executes the result given a final location (jsp page, action, etc) and the action invocation
+     * (the state in which the action was executed). Subclasses must implement this class to handle
+     * custom logic for result handling.
+     *
+     * @param finalLocation the location (jsp page, action, etc) to go to.
+     * @param invocation    the execution state of the action.
+     * @throws Exception if an error occurs while executing the result.
+     */
+    protected abstract void doExecute(String finalLocation, ActionInvocation invocation) throws Exception;
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/VelocityResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/VelocityResult.java b/core/src/main/java/org/apache/struts2/result/VelocityResult.java
new file mode 100644
index 0000000..810d191
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/VelocityResult.java
@@ -0,0 +1,233 @@
+/*
+ * $Id$
+ *
+ * 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.StrutsConstants;
+import org.apache.struts2.views.JspSupportServlet;
+import org.apache.struts2.views.velocity.VelocityManager;
+import org.apache.velocity.Template;
+import org.apache.velocity.app.VelocityEngine;
+import org.apache.velocity.context.Context;
+
+import javax.servlet.Servlet;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.jsp.JspFactory;
+import javax.servlet.jsp.PageContext;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * Using the Servlet container's {@link JspFactory}, this result mocks a JSP
+ * execution environment and then displays a Velocity template that will be
+ * streamed directly to the servlet output.
+ *
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>location (default)</b> - the location of the template to process.</li>
+ *
+ * <li><b>parse</b> - true by default. If set to false, the location param will
+ * not be parsed for Ognl expressions.</li>
+ *
+ * </ul>
+ * <p>
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ * </p>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * &lt;result name="success" type="velocity"&gt;
+ *   &lt;param name="location"&gt;foo.vm&lt;/param&gt;
+ * &lt;/result&gt;
+ * <!-- END SNIPPET: example --></pre>
+ *
+ */
+public class VelocityResult extends StrutsResultSupport {
+
+    private static final long serialVersionUID = 7268830767762559424L;
+
+    private static final Logger LOG = LogManager.getLogger(VelocityResult.class);
+    
+    private String defaultEncoding;
+    private VelocityManager velocityManager;
+    private JspFactory jspFactory = JspFactory.getDefaultFactory();
+
+    public VelocityResult() {
+        super();
+    }
+
+    public VelocityResult(String location) {
+        super(location);
+    }
+    
+    @Inject(StrutsConstants.STRUTS_I18N_ENCODING)
+    public void setDefaultEncoding(String val) {
+        defaultEncoding = val;
+    }
+    
+    @Inject
+    public void setVelocityManager(VelocityManager mgr) {
+        this.velocityManager = mgr;
+    }
+
+    /**
+     * Creates a Velocity context from the action, loads a Velocity template and executes the
+     * template. Output is written to the servlet output stream.
+     *
+     * @param finalLocation the location of the Velocity template
+     * @param invocation    an encapsulation of the action execution state.
+     * @throws Exception if an error occurs when creating the Velocity context, loading or executing
+     *                   the template or writing output to the servlet response stream.
+     */
+    public void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+        ValueStack stack = ActionContext.getContext().getValueStack();
+
+        HttpServletRequest request = ServletActionContext.getRequest();
+        HttpServletResponse response = ServletActionContext.getResponse();
+        ServletContext servletContext = ServletActionContext.getServletContext();
+        Servlet servlet = JspSupportServlet.jspSupportServlet;
+
+        velocityManager.init(servletContext);
+
+        boolean usedJspFactory = false;
+        PageContext pageContext = (PageContext) ActionContext.getContext().get(ServletActionContext.PAGE_CONTEXT);
+
+        if (pageContext == null && servlet != null) {
+            pageContext = jspFactory.getPageContext(servlet, request, response, null, true, 8192, true);
+            ActionContext.getContext().put(ServletActionContext.PAGE_CONTEXT, pageContext);
+            usedJspFactory = true;
+        }
+
+        try {
+            String encoding = getEncoding(finalLocation);
+            String contentType = getContentType(finalLocation);
+
+            if (encoding != null) {
+                contentType = contentType + ";charset=" + encoding;
+            }
+
+            Template t = getTemplate(stack, velocityManager.getVelocityEngine(), invocation, finalLocation, encoding);
+
+            Context context = createContext(velocityManager, stack, request, response, finalLocation);
+            Writer writer = new OutputStreamWriter(response.getOutputStream(), encoding);
+
+
+            response.setContentType(contentType);
+
+            t.merge(context, writer);
+
+            // always flush the writer (we used to only flush it if this was a jspWriter, but someone asked
+            // to do it all the time (WW-829). Since Velocity support is being deprecated, we'll oblige :)
+            writer.flush();
+        } catch (Exception e) {
+            LOG.error("Unable to render velocity template: '{}'", finalLocation, e);
+            throw e;
+        } finally {
+            if (usedJspFactory) {
+                jspFactory.releasePageContext(pageContext);
+            }
+        }
+    }
+
+    /**
+     * Retrieve the content type for this template.
+     * <p/>
+     * People can override this method if they want to provide specific content types for specific templates (eg text/xml).
+     *
+     * @return The content type associated with this template (default "text/html")
+     */
+    protected String getContentType(String templateLocation) {
+        return "text/html";
+    }
+
+    /**
+     * Retrieve the encoding for this template.
+     * <p/>
+     * People can override this method if they want to provide specific encodings for specific templates.
+     *
+     * @return The encoding associated with this template (defaults to the value of 'struts.i18n.encoding' property)
+     */
+    protected String getEncoding(String templateLocation) {
+        String encoding = defaultEncoding;
+        if (encoding == null) {
+            encoding = System.getProperty("file.encoding");
+        }
+        if (encoding == null) {
+            encoding = "UTF-8";
+        }
+        return encoding;
+    }
+
+    /**
+     * Given a value stack, a Velocity engine, and an action invocation, this method returns the appropriate
+     * Velocity template to render.
+     *
+     * @param stack      the value stack to resolve the location again (when parse equals true)
+     * @param velocity   the velocity engine to process the request against
+     * @param invocation an encapsulation of the action execution state.
+     * @param location   the location of the template
+     * @param encoding   the charset encoding of the template
+     * @return the template to render
+     * @throws Exception when the requested template could not be found
+     */
+    protected Template getTemplate(ValueStack stack, VelocityEngine velocity, ActionInvocation invocation, String location, String encoding) throws Exception {
+        if (!location.startsWith("/")) {
+            location = invocation.getProxy().getNamespace() + "/" + location;
+        }
+
+        Template template = velocity.getTemplate(location, encoding);
+
+        return template;
+    }
+
+    /**
+     * Creates the VelocityContext that we'll use to render this page.
+     *
+     * @param velocityManager a reference to the velocityManager to use
+     * @param stack           the value stack to resolve the location against (when parse equals true)
+     * @param location        the name of the template that is being used
+     * @return the a minted Velocity context.
+     */
+    protected Context createContext(VelocityManager velocityManager, ValueStack stack, HttpServletRequest request, HttpServletResponse response, String location) {
+        return velocityManager.createContext(stack, request, response);
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java b/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
index e5258e6..0775f55 100644
--- a/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
+++ b/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
@@ -38,7 +38,7 @@ import freemarker.template.TemplateModelException;
 import org.apache.commons.lang3.ObjectUtils;
 import org.apache.struts2.ServletActionContext;
 import org.apache.struts2.StrutsStatics;
-import org.apache.struts2.dispatcher.StrutsResultSupport;
+import org.apache.struts2.result.StrutsResultSupport;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/resources/struts-default.xml
----------------------------------------------------------------------
diff --git a/core/src/main/resources/struts-default.xml b/core/src/main/resources/struts-default.xml
index 5b82fe0..33057cb 100644
--- a/core/src/main/resources/struts-default.xml
+++ b/core/src/main/resources/struts-default.xml
@@ -168,16 +168,16 @@
     <package name="struts-default" abstract="true">
         <result-types>
             <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
-            <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>
+            <result-type name="dispatcher" class="org.apache.struts2.result.ServletDispatcherResult" default="true"/>
             <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>
-            <result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
-            <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
-            <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
-            <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
-            <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>
+            <result-type name="httpheader" class="org.apache.struts2.result.HttpHeaderResult"/>
+            <result-type name="redirect" class="org.apache.struts2.result.ServletRedirectResult"/>
+            <result-type name="redirectAction" class="org.apache.struts2.result.ServletActionRedirectResult"/>
+            <result-type name="stream" class="org.apache.struts2.result.StreamResult"/>
+            <result-type name="velocity" class="org.apache.struts2.result.VelocityResult"/>
             <result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
-            <result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />
-            <result-type name="postback" class="org.apache.struts2.dispatcher.PostbackResult" />
+            <result-type name="plainText" class="org.apache.struts2.result.PlainTextResult" />
+            <result-type name="postback" class="org.apache.struts2.result.PostbackResult" />
         </result-types>
 
         <interceptors>

http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java b/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
index 1806573..aee8473 100644
--- a/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
+++ b/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
@@ -39,7 +39,7 @@ import com.opensymphony.xwork2.security.DefaultExcludedPatternsChecker;
 import com.opensymphony.xwork2.security.ExcludedPatternsChecker;
 import com.opensymphony.xwork2.util.location.LocatableProperties;
 import com.opensymphony.xwork2.validator.ValidationInterceptor;
-import org.apache.struts2.dispatcher.ServletDispatcherResult;
+import org.apache.struts2.result.ServletDispatcherResult;
 import org.apache.struts2.interceptor.TokenInterceptor;
 import org.apache.struts2.interceptor.TokenSessionStoreInterceptor;
 import org.apache.struts2.views.jsp.ui.DoubleValidationAction;


Mime
View raw message