RequestImpl


1   /*
2    * Copyright 1999-2002,2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.commons.latka.http;
18  // java imports
19  import java.net.URL  ;
20  import java.io.ByteArrayInputStream  ;
21  import java.io.InputStream  ;
22  import java.io.IOException  ;
23  import java.util.List  ;
24  import java.util.LinkedList  ;
25  // latka imports
26  import org.apache.commons.httpclient.HostConfiguration;
27  import org.apache.commons.httpclient.UsernamePasswordCredentials;
28  import org.apache.commons.httpclient.HttpClient;
29  import org.apache.commons.httpclient.HttpException;
30  import org.apache.commons.httpclient.HttpMethod;
31  import org.apache.commons.httpclient.HttpState;
32  import org.apache.commons.httpclient.HttpMethodBase;
33  import org.apache.commons.httpclient.methods.PostMethod;
34  // log4j imports
35  import org.apache.log4j.Category;
36  
37  /**
38   * An implementation of a Latka Request interface based on the Jakarta Commons
39   * HttpClient package.
40   *
41   * @todo pass proxy host and port to httpclient
42   * @author <a HREF="mailto:dsale@us.britannica.com">Doug Sale</a>
43   * @author <a HREF="mailto:mdelagra@us.britannica.com">Morgan Delagrange</a>
44   * @author dIon Gillard
45   * @version $Id: RequestImpl.java 155424 2005-02-26 13:09:29Z dirkv $
46   * @see Request
47   */
48  public class RequestImpl implements Request {
49      
50      /** Standard HTTP Port */
51      public static final int HTTP_PORT = 80;
52      
53      /** Standard HTTPS Port */
54      public static final int HTTPS_PORT = 443;
55      /** host the request is being made on */
56      protected String    _host   = null;
57      /** port the request is being made on */
58      protected int     _port   = -1;
59      /** http method being used to make the request */
60      protected int     _method = -1;
61      /** http session the request is part of */
62      protected SessionImpl _session    = null;
63      /** credentials for the request */
64      protected Credentials _credentials = null;
65      /** http method implementation */
66      protected HttpMethod  _httpMethod = null;
67      /** URL being requested */
68      protected URL           _targetURL  = null;
69      /** query string portion of the URL */
70      protected String        _query      = null;
71      /** time taken for the request in milliseconds */
72      protected long        _requestTiming = -1;
73      /** name given to the request */
74      protected String        _label      = null;
75      /** headers sent with this request */
76      protected RequestHeaders _requestHeaders = new RequestHeadersImpl();
77      /** parameters sent with this request */
78      protected Parameters _parameters = new ParametersImpl();
79      /** manually constructed post body */
80      protected String   _requestBody = null;
81      /** whether or not redirect responses should be followed as part of the
82          request processing*/
83      protected boolean _followRedirects = true;
84      /** object used to perform the http requests */
85      protected HttpClient _httpClient = new HttpClient();
86      /** proxy used to perform the requests */
87      private Proxy _proxy = null;
88      /** log4j category used when logging messages */
89      protected static final Category _log = 
90          Category.getInstance(RequestImpl.class);
91  
92      /**
93       * HTTP Version 1.0
94       */
95      private static final String   HTTP_10 = "1.0";
96      /**
97       * HTTP Version 1.1
98       */    
99      private static final String   HTTP_11 = "1.1";
100 
101     protected String   _httpVersion = HTTP_11;
102 
103     protected List   _visitedURLs = new LinkedList  ();
104 
105     /**
106      * Create a request for the specified URL, process using the supplied method
107      * and use the supplied state and session for persistent data
108      * @param url the URL to send the request to
109      * @param httpMethod the http method to use in sending the request, as 
110      *        defined in {@link Request}
111      * @param state shared information across requests
112      * @param session state shared across servers and requests
113      */
114     protected RequestImpl(URL   url, int httpMethod, HttpState state,
115         SessionImpl session) {
116         this(null, url, httpMethod, state, session, true);
117     }
118     
119     /**
120      * Create a RequestImpl
121      *
122      * @param label       a name for the request
123      * @param url         the url that this request embodies
124      * @param httpMethod  the method by which this request should be executed
125      * @param state       shared information across requests
126      * @param session     the session that the request should be executed in
127      * @param followRedirects whether http redirect responses should be honoured
128      */
129     protected RequestImpl(String   label, URL   url, int httpMethod, 
130         HttpState state, SessionImpl session, boolean followRedirects) {
131             
132         _followRedirects = followRedirects;
133         _method = httpMethod;
134         _httpClient.setState(state);
135         
136         _label = label;
137         _query = url.getQuery();
138         
139         _session = session;
140         _targetURL = url;
141         _httpMethod = MethodFactory.getInstance(httpMethod, url);
142         if (_query != null) {
143             _httpMethod.setQueryString(_query);
144         }
145         _httpMethod.setFollowRedirects(followRedirects);
146     }
147     
148     /**
149      * Returns the object implementing the HttpMethod
150      * (get, post, etc.) for this request.
151      *
152      * @return the underlying HttpMethod object representing the request/
153      *      response pair.
154      */
155     protected HttpMethod getHttpMethod() {
156         return _httpMethod;
157     }
158     
159     /**
160      * Defined in the implemented interface
161      * @return the headers used for this request
162      * @see Request#getHeaders()
163      */
164     public RequestHeaders getHeaders() {
165         return _requestHeaders;
166     }
167     
168     /**
169      * Defined in the implemented interface
170      * @param requestHeaders new value for the headers property
171      * @see Request#setHeaders(RequestHeaders)
172      */
173     public void setHeaders(RequestHeaders requestHeaders) {
174         _requestHeaders = requestHeaders;
175     }
176     
177     /**
178      * Defined in the implemented interface
179      * @return the parameters property
180      * @see Request#getParameters()
181      */
182     public Parameters getParameters() {
183         return _parameters;
184     }
185 
186     /**
187      * Defined in the implemented interface
188      * @see Request#setRequestBody(String)
189      */
190     public void setRequestBody(String   body) {
191         _requestBody = body;
192     }
193     
194     /**
195      * Defined in the implemented interface
196      * @param parameters new value for parameters property
197      * @see Request#setParameters(Parameters)
198      */
199     public void setParameters(Parameters parameters) {
200         _parameters = parameters;
201     }
202     
203     /**
204      * Defined in the implemented interface
205      * @param credentials username and password to use
206      * @see Request#setCredentials(Credentials)
207      */
208     public void setCredentials(Credentials credentials) {
209         // null implies that this credential is the default (vs. specifying a 
210         // realm)
211         UsernamePasswordCredentials creds = new UsernamePasswordCredentials(
212             credentials.getUserName(), credentials.getPassword());
213         _session._state.setCredentials(null, creds);
214         _credentials = credentials;
215     }
216 
217     public Credentials getCredentials() {
218         return _credentials;
219     }
220     
221     /**
222      * Execute the request - perform the http interaction.
223      * Since HttpClient doesn't follow off-server
224      * redirects, execute() may have to construct further 
225      * requests that call this method.
226      * 
227      * @return a {@link Response} detailing the html etc
228      * @exception IOException
229      *                   when there are problems reading and writing
230      * @see Request#execute()
231      */
232     protected Response executeRequestPerHost() throws IOException   {
233         
234         // set the request headers in HTTPClient
235         List   headers = _requestHeaders.getHeaders();
236         for (int i = 0; i < headers.size(); ++i) {
237             String  [] header = (String  []) headers.get(i);
238             _httpMethod.addRequestHeader(header[0], header[1]);
239         }
240         
241         if (_requestBody != null) {
242             InputStream    is = new ByteArrayInputStream  (
243                 _requestBody.getBytes("ISO-8859-1"));
244             ((PostMethod) _httpMethod).setRequestBody(is);
245         } else {
246             List   parameters = _parameters.getParameters();
247             for (int i = 0; i < parameters.size(); ++i) {
248                 String  [] parameter = (String  []) parameters.get(i);
249                 addHttpClientParameter(parameter[0], parameter[1]);
250             }
251         }
252         
253         // for timing
254         long startDate = System.currentTimeMillis();
255         
256         Response response = null;
257         try {
258             // open the connection
259             openConnection();
260             
261             _log.debug("executing request");
262             
263             _httpClient.executeMethod(_httpMethod);
264             
265             _log.debug("request executed");
266             
267             response = new ResponseImpl(this);
268 
269             // Cache the response body to allow it to be accessed
270             // after the http connection is closed.
271             String   sideEffectOnly = response.getResource();
272             
273             // set the referer
274             // note: If followRedirects
275             // is enabled, HTTPClient may return a path
276             // that is different from the initial request.
277             // HTTPClient will not follow redirects to another
278             // host, port, or protocol; in that event, it will always
279             // return a 301 or 302.
280             _session.setReferer(new URL  (_targetURL.getProtocol(), _host, _port,
281                 _httpMethod.getPath()));
282             
283         } catch (HttpException e) {
284             throw new IOException  (e.toString());
285         } catch (IOException   e) {
286             // rethrow it after closing the connection
287             throw e;
288         } finally {
289             try {
290                 closeConnection(); 
291                 // FIXME: Shouldn't use Exception here.
292             } catch (Exception   e) {
293                 e.printStackTrace();
294             }
295         }
296         
297         
298         _requestTiming = System.currentTimeMillis() - startDate;
299         
300         if (_log.isInfoEnabled()) {
301             _log.info("response obtained (response logging disabled because "
302                 + "some responses are binary)");
303         }
304         
305         return response;
306     }
307     
308     /**
309      * Executes the request.  In the event of a 301 or 302,
310      * this method may need to create a new Request, 
311      * due to an idiosyncracy of
312      * HttpClient.  In that case, the Response.getRequest()
313      * method will return the actual Request that was executed.
314      */
315     public Response execute() throws IOException   {
316         Response response = executeRequestPerHost();
317 
318         if (followRedirects() == false) {
319             return response;
320         }
321 
322         Request lastRequest = this;
323         // execute the request until either we get a non-redirect response, or
324         // we visit a URL we have already visited
325         while (response.getStatusCode() == 301 || response.getStatusCode() == 302) {
326             // follow the redirect
327             URL   url = new URL  (response.getHeader("location"));
328 
329             if (_visitedURLs.contains(url.toString())) {
330                 return response;
331             }
332 
333             Request request = _session.createRequest(lastRequest.getLabel(), url,
334                 lastRequest.getMethod(), lastRequest.getVersion(), true, getProxy());
335             request.setParameters(lastRequest.getParameters());
336             request.setHeaders(lastRequest.getHeaders());
337             Credentials credentials = lastRequest.getCredentials();
338             if (credentials != null) {
339                 request.setCredentials(credentials);
340             }
341             response = request.execute();
342             _visitedURLs.add(url.toString());
343             lastRequest = request;
344         }
345 
346         return response;
347     }
348 
349     /**
350      * Get the URL used for the request
351      * @return the {@link URL} of the request
352      * @see Request#getURL
353      */
354     public URL   getURL() {
355         return _targetURL;
356     }
357     
358     /**
359      * Get the label used for the request
360      * @return the label used to create the request
361      * @see Request#getLabel
362      */
363     public String   getLabel() {
364         return _label;
365     }
366     
367     /**
368      * Add a parameter (name and value) to the request
369      * @param name the name of the parameter to be added
370      * @param value the value of the parameter to be added
371      * @see Request#addParameter(String,String)
372      */
373     public void addParameter(String   name, String   value) {
374         _parameters.addParameter(name, value);
375     }
376     
377     /**
378      * Associate a parameter with this request.
379      *
380      * @param name  the lvalue of the parameter - must not be null
381      * @param value  the rvalue of the parameter - must not be null
382      */
383     protected void addHttpClientParameter(String   name, String   value) {
384         if (name == null) {
385             throw new NullPointerException  ("name parameter is null");
386         }
387         
388         if (value == null) {
389             throw new NullPointerException  ("value parameter is null");
390         }
391         _log.info("adding parameter, name: " + name + ", value: " + value);
392         
393         if (_httpMethod instanceof PostMethod) {
394             // addParameter adds to POST Entity, not URL
395             ((PostMethod) _httpMethod).addParameter(name, value);
396         } else {
397             StringBuffer   query = new StringBuffer  ();
398 
399             // setParameter adds to URL as query string
400             if (_query == null || _query.equals("")) {
401                 query.append(name);
402                 query.append("=");
403                 query.append(value);
404             } else {
405                 query.append(_query);
406                 query.append("&");
407                 query.append(name);
408                 query.append("=");
409                 query.append(value);
410             }
411             _query = query.toString();
412             ((HttpMethod) _httpMethod).setQueryString(_query);
413         }
414     }
415     
416     /**
417      * Set a header in the request
418      *
419      * @param headerName name of any HTTP request header
420      * @param headerValue value of that header
421      */
422     public void addHeader(String   headerName, String   headerValue) {
423         _requestHeaders.addHeader(headerName, headerValue);
424     }
425     
426     /**
427      * Retrieve the session associated with this request.
428      *
429      * @return a <code>Session</code> object
430      */
431     public Session getSession() {
432         return _session;
433     }
434     
435     /**
436      * @return the time it took to execute this request in milliseconds
437      * or -1 if the request has not yet been executed
438      */
439     public int getRequestTiming() {
440         return (int) _requestTiming;
441     }
442     
443     /**
444      * opens an HTTP connection.  This method is called
445      * before executing the method.
446      *
447      * @exception IOException
448      *                   if the server could not be contacted
449      */
450     protected void openConnection() throws IOException   {
451         _log.debug("Opening connection");
452         
453         URL   url = getURL();
454         String   protocol = url.getProtocol();
455         String   host = url.getHost();
456         int port = url.getPort();
457         
458         // explicitly set port if not in url,
459         // just for storing away and comparison
460         if (port == -1) {
461             if (protocol.equals("http")) {
462                 port = HTTP_PORT;
463             } else if (protocol.equals("https")) {
464                 port = HTTPS_PORT;
465             } else {
466                 throw new IllegalArgumentException  ("Unsupported Protocol");
467             }
468         }
469         
470         // save session values
471         _host = host;
472         _port = port;
473         
474         HostConfiguration hostConfiguration = _httpClient.getHostConfiguration();
475         hostConfiguration.setHost(host, port, protocol);
476         if (getProxy() != null) {
477             hostConfiguration.setProxy(getProxy().getHost(), getProxy().getPort());
478         }
479         
480         _log.debug("connection open");
481     }
482     
483     /**
484      * Closes the http connection associated with the request
485      * @throws IOException if there are problems closing the connection
486      */
487     protected void closeConnection() throws IOException   {
488         _log.debug("closing connection");
489         _httpMethod.releaseConnection();
490         _log.debug("connection closed");
491     }
492     
493     /**
494      * Defined in the interface
495      * @return whether the request will honour http redirect status codes
496      * @see Request#followRedirects()
497      */
498     public boolean followRedirects() {
499         return _followRedirects;
500     }
501     
502     /**
503      * Defined in the interface
504      * @return the http method being used for the request, as defined in the
505      *      interface
506      * @see Request#getMethod
507      */
508     public int getMethod() {
509         return _method;
510     }
511     
512     /** Getter for property proxy.
513      * @return Value of property proxy.
514      */
515     public Proxy getProxy() {
516         return _proxy;
517     }
518     
519     /** Setter for property proxy.
520      * @param proxy New value of property proxy.
521      */
522     public void setProxy(Proxy proxy) {
523         _proxy = proxy;
524     }
525     
526     /**
527      * Sets the HTTP version for this request.  If
528      * the version provided is not 1.0 or 1.1, then
529      * 1.1 will be used.
530      *
531      * @param version  HTTP version
532      */
533     public void setVersion(String   version) {
534         ((HttpMethodBase) _httpMethod).setHttp11(!HTTP_10.equals(version));
535         _httpVersion = version;
536     }
537 
538     /**
539      * Get the HTTP version to use in this request.
540      * 
541      * @return HTTP version for the request
542      */
543     public String   getVersion() {
544         return _httpVersion;
545     }
546 }
547
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags