| /* |
| * Copyright 2002,2004 The Apache Software Foundation. |
| * |
| * Licensed 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.commons.jelly.tags.http; |
| |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.apache.commons.httpclient.HttpClient; |
| import org.apache.commons.httpclient.HttpMethod; |
| import org.apache.commons.httpclient.NameValuePair; |
| import org.apache.commons.jelly.JellyTagException; |
| import org.apache.commons.jelly.TagSupport; |
| import org.apache.commons.jelly.XMLOutput; |
| |
| /** |
| * The base tag for all http requests |
| * |
| * @author dion |
| * @version $Id: HttpTagSupport.java,v 1.3 2002/07/14 16:51:33 dion Exp $ |
| */ |
| public abstract class HttpTagSupport extends TagSupport { |
| |
| /** unique identifier of the tag/ variable to store result in */ |
| private String _var; |
| |
| /** |
| * the path to be tested relative to the host/port specifed on the parent |
| * {@link SuiteTag suite tag}. |
| * Either this property and the suite's host |
| * must be provided, or the {@link #getUrl() url} property must be specifed |
| */ |
| private String _path; |
| |
| /** |
| * The complete uri to be processed |
| * Either this property or the {@link #getPath() path} and the suite's host |
| * must be provided. |
| */ |
| private String _uri; |
| |
| /** whether or not to follow redirects */ |
| private boolean _followRedirects = false; |
| /** list of parameters as name value pairs */ |
| private List _parameters; |
| /** list of headers as name value pairs */ |
| private List _requestHeaders; |
| /** the header name for the user agent */ |
| private static final String HEADER_NAME_USER_AGENT = "User-Agent"; |
| |
| /** |
| * Creates a new instance of HttpTag |
| */ |
| public HttpTagSupport() { |
| setParameters(new ArrayList()); |
| setRequestHeaders(new ArrayList()); |
| } |
| |
| /** |
| * @return the url specified by the tag, either the url if not null, or |
| * a combination of the host, port and path |
| */ |
| public String getResolvedUrl() { |
| if (getUri() != null) { |
| return getUri(); |
| } else { |
| // build it from path, host and optionally port |
| SessionTag session = (SessionTag) findAncestorWithClass( |
| SessionTag.class); |
| String host = session.getHost(); |
| String port = session.getPort(); |
| // short term hack, need to add port and security in |
| return "http://" + host + getPath(); |
| } |
| } |
| |
| /** |
| * A method that must be implemented by subclasses to provide the |
| * {@link HttpMethod url method} implementation |
| * |
| * @return a HttpUrlMethod implementation |
| * @throws MalformedURLException when the {@link getUrl() url} or |
| * {@link #getPath() path} is invalid |
| */ |
| protected abstract HttpMethod getHttpMethod() |
| throws MalformedURLException; |
| |
| /** |
| * Perform the tag functionality. In this case, get the http url method |
| * execute it and make it available for validation |
| * |
| * @param xmlOutput where to send output |
| * @throws JellyTagException when an error occurs |
| */ |
| public void doTag(XMLOutput xmlOutput) throws JellyTagException { |
| // allow nested tags first, e.g body |
| invokeBody(xmlOutput); |
| |
| // track request execution |
| long start = System.currentTimeMillis(); |
| HttpMethod urlMethod = null; |
| try { |
| urlMethod = getConfiguredHttpMethod(); |
| getHttpClient().executeMethod(urlMethod); |
| } |
| catch (MalformedURLException e) { |
| throw new JellyTagException(e); |
| } |
| catch (IOException e) { |
| throw new JellyTagException(e); |
| } |
| long end = System.currentTimeMillis(); |
| |
| // set variable to value |
| if (getVar() != null) { |
| getContext().setVariable(getVar(), urlMethod); |
| getContext().setVariable(getVar() + ".responseTime", |
| String.valueOf(end - start)); |
| } |
| } |
| |
| /** |
| * retrieve the {@link HttpUrlMethod method} from the subclass and |
| * configure it ready for execution |
| * |
| * @return a configured {@link HttpUrlMethod method} |
| * @throws MalformedURLException when retrieving the URL fails |
| */ |
| private HttpMethod getConfiguredHttpMethod() throws |
| MalformedURLException { |
| // retrieve and configure url method |
| HttpMethod urlMethod = getHttpMethod(); |
| urlMethod.setFollowRedirects(isFollowRedirects()); |
| // add request headers |
| NameValuePair header = null; |
| for (int index = 0; index < getRequestHeaders().size(); index++) { |
| header = (NameValuePair) getRequestHeaders().get(index); |
| urlMethod.addRequestHeader(header.getName(), header.getValue()); |
| } |
| // add parameters |
| setParameters(urlMethod); |
| // add the default user agent to the list if one doesn't exist |
| // and the session tag does exist and have a user agent |
| if (urlMethod.getRequestHeader(HttpTagSupport.HEADER_NAME_USER_AGENT) |
| == null && getSessionTag() != null |
| && getSessionTag().getUserAgent() != null) { |
| |
| urlMethod.addRequestHeader(HttpTagSupport.HEADER_NAME_USER_AGENT, |
| getSessionTag().getUserAgent()); |
| } |
| return urlMethod; |
| } |
| |
| /** |
| * Set the current parameters on the url method ready for processing |
| * |
| * @param method the {@link HttpUrlMethod method} to configure |
| * @throws MalformedURLException when {@link #getHttpUrlMethod()} does |
| */ |
| protected void setParameters(HttpMethod method) throws |
| MalformedURLException { |
| if (getParameters().size() > 0) { |
| NameValuePair[] parameters = (NameValuePair[]) getParameters(). |
| toArray(new NameValuePair[0]); |
| method.setQueryString(parameters); |
| } |
| } |
| |
| /** |
| * retrieve the optional parent session tag |
| * |
| * @return the ancestor tag with class {@link SessionTag} or null if |
| * not found |
| */ |
| private SessionTag getSessionTag() { |
| SessionTag sessionTag = (SessionTag) findAncestorWithClass( |
| SessionTag.class); |
| return sessionTag; |
| } |
| |
| /** |
| * return a HttpClient shared on the session tag, or a new one if no |
| * session tag exists |
| * |
| * @return the shared http client from the session tag, or create a new one. |
| */ |
| private HttpClient getHttpClient() { |
| SessionTag session = getSessionTag(); |
| HttpClient client = null; |
| if (session != null) { |
| client = session.getHttpClient(); |
| client.setStrictMode(session.isStrictMode()); |
| } else { |
| client = new HttpClient(); |
| } |
| return client; |
| } |
| |
| /** |
| * Add a parameter to the list |
| * |
| * @param name the parameter name |
| * @param value the parameter value |
| */ |
| public void addParameter(String name, String value) { |
| getParameters().add(new NameValuePair(name, value)); |
| } |
| |
| /** |
| * Add a request header to the list |
| * |
| * @param name the header name |
| * @param value the header value |
| */ |
| public void addRequestHeader(String name, String value) { |
| getRequestHeaders().add(new NameValuePair(name, value)); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Property accessors/mutators |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Getter for property var. |
| * |
| * @return Value of property var. |
| */ |
| public String getVar() { |
| return _var; |
| } |
| |
| /** |
| * Setter for property var. |
| * |
| * @param var New value of property var. |
| */ |
| public void setVar(String var) { |
| _var = var; |
| } |
| |
| /** |
| * Getter for property path. |
| * |
| * @return Value of property path. |
| */ |
| public String getPath() { |
| return _path; |
| } |
| |
| /** |
| * Setter for property path. |
| * |
| * @param path New value of property path. |
| */ |
| public void setPath(String path) { |
| _path = path; |
| } |
| |
| /** |
| * Getter for property uri. |
| * |
| * @return Value of property uri. |
| */ |
| public String getUri() { |
| return _uri; |
| } |
| |
| /** |
| * Setter for property uri. |
| * |
| * @param uri New value of property uri. |
| */ |
| public void setUri(String uri) { |
| _uri = uri; |
| } |
| |
| /** |
| * Getter for property followRedirects. |
| * |
| * @return Value of property followRedirects. |
| */ |
| public boolean isFollowRedirects() { |
| return _followRedirects; |
| } |
| |
| /** |
| * Setter for property followRedirects. |
| * |
| * @param followRedirects New value of property followRedirects. |
| */ |
| public void setFollowRedirects(boolean followRedirects) { |
| _followRedirects = followRedirects; |
| } |
| |
| /** |
| * Getter for property parameters. |
| * |
| * @return Value of property parameters. |
| */ |
| public List getParameters() { |
| return _parameters; |
| } |
| |
| /** |
| * Setter for property parameters. |
| * |
| * @param parameters New value of property parameters. |
| */ |
| public void setParameters(List parameters) { |
| _parameters = parameters; |
| } |
| |
| /** |
| * Getter for property requestHeaders. |
| * |
| * @return Value of property requestHeaders. |
| */ |
| public List getRequestHeaders() { |
| return _requestHeaders; |
| } |
| |
| /** |
| * Setter for property requestHeaders. |
| * |
| * @param requestHeaders New value of property requestHeaders. |
| */ |
| public void setRequestHeaders(List requestHeaders) { |
| _requestHeaders = requestHeaders; |
| } |
| |
| } |