View Javadoc

1   /*
2    * ====================================================================
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   * ====================================================================
20   *
21   * This software consists of voluntary contributions made by many
22   * individuals on behalf of the Apache Software Foundation.  For more
23   * information on the Apache Software Foundation, please see
24   * <http://www.apache.org/>.
25   *
26   */
27  
28  package org.apache.http.localserver;
29  
30  import java.io.IOException;
31  import java.io.InputStream;
32  import java.io.OutputStream;
33  import java.util.Locale;
34  
35  import org.apache.http.Consts;
36  import org.apache.http.HttpException;
37  import org.apache.http.HttpRequest;
38  import org.apache.http.HttpResponse;
39  import org.apache.http.HttpStatus;
40  import org.apache.http.MethodNotSupportedException;
41  import org.apache.http.entity.AbstractHttpEntity;
42  import org.apache.http.protocol.HttpContext;
43  import org.apache.http.protocol.HttpRequestHandler;
44  
45  /**
46   * A handler that generates random data.
47   */
48  public class RandomHandler implements HttpRequestHandler {
49  
50      /**
51       * Handles a request by generating random data.
52       * The length of the response can be specified in the request URI
53       * as a number after the last /. For example /random/whatever/20
54       * will generate 20 random bytes in the printable ASCII range.
55       * If the request URI ends with /, a random number of random bytes
56       * is generated, but at least one.
57       *
58       * @param request   the request
59       * @param response  the response
60       * @param context   the context
61       *
62       * @throws HttpException    in case of a problem
63       * @throws IOException      in case of an IO problem
64       */
65      @Override
66      public void handle(final HttpRequest request,
67                         final HttpResponse response,
68                         final HttpContext context)
69          throws HttpException, IOException {
70  
71          final String method = request.getRequestLine().getMethod().toUpperCase(Locale.ROOT);
72          if (!"GET".equals(method) && !"HEAD".equals(method)) {
73              throw new MethodNotSupportedException
74                  (method + " not supported by " + getClass().getName());
75          }
76  
77          final String uri = request.getRequestLine().getUri();
78          final int  slash = uri.lastIndexOf('/');
79          int length = -1;
80          if (slash < uri.length()-1) {
81              try {
82                  // no more than Integer, 2 GB ought to be enough for anybody
83                  length = Integer.parseInt(uri.substring(slash+1));
84  
85                  if (length < 0) {
86                      response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
87                      response.setReasonPhrase("LENGTH " + length);
88                  }
89              } catch (final NumberFormatException nfx) {
90                  response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
91                  response.setReasonPhrase(nfx.toString());
92              }
93          } else {
94              // random length, but make sure at least something is sent
95              length = 1 + (int)(Math.random() * 79.0);
96          }
97  
98          if (length >= 0) {
99  
100             response.setStatusCode(HttpStatus.SC_OK);
101 
102             if (!"HEAD".equals(method)) {
103                 final RandomEntity entity = new RandomEntity(length);
104                 entity.setContentType("text/plain; charset=US-ASCII");
105                 response.setEntity(entity);
106             } else {
107                 response.setHeader("Content-Type",
108                                    "text/plain; charset=US-ASCII");
109                 response.setHeader("Content-Length",
110                                    String.valueOf(length));
111             }
112         }
113 
114     } // handle
115 
116 
117     /**
118      * An entity that generates random data.
119      * This is an outgoing entity, it supports {@link #writeTo writeTo}
120      * but not {@link #getContent getContent}.
121      */
122     public static class RandomEntity extends AbstractHttpEntity {
123 
124         /** The range from which to generate random data. */
125         private final static byte[] RANGE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
126                 .getBytes(Consts.ASCII);
127 
128         /** The length of the random data to generate. */
129         protected final long length;
130 
131 
132         /**
133          * Creates a new entity generating the given amount of data.
134          *
135          * @param len   the number of random bytes to generate,
136          *              0 to maxint
137          */
138         public RandomEntity(final long len) {
139             length = len;
140         }
141 
142         /**
143          * Tells that this entity is not streaming.
144          *
145          * @return      false
146          */
147         @Override
148         public final boolean isStreaming() {
149             return false;
150         }
151 
152         /**
153          * Tells that this entity is repeatable, in a way.
154          * Repetitions will generate different random data,
155          * unless perchance the same random data is generated twice.
156          *
157          * @return      {@code true}
158          */
159         @Override
160         public boolean isRepeatable() {
161             return true;
162         }
163 
164         /**
165          * Obtains the size of the random data.
166          *
167          * @return      the number of random bytes to generate
168          */
169         @Override
170         public long getContentLength() {
171             return length;
172         }
173 
174 
175         /**
176          * Not supported.
177          * This method throws an exception.
178          *
179          * @return      never anything
180          */
181         @Override
182         public InputStream getContent() {
183             throw new UnsupportedOperationException();
184         }
185 
186 
187         /**
188          * Generates the random content.
189          *
190          * @param out   where to write the content to
191          */
192         @Override
193         public void writeTo(final OutputStream out) throws IOException {
194 
195             final int blocksize = 2048;
196             int       remaining = (int) length; // range checked in constructor
197             final byte[]         data = new byte[Math.min(remaining, blocksize)];
198 
199             while (remaining > 0) {
200                 final int end = Math.min(remaining, data.length);
201 
202                 double value = 0.0;
203                 for (int i = 0; i < end; i++) {
204                     // we get 5 random characters out of one random value
205                     if (i%5 == 0) {
206                         value = Math.random();
207                     }
208                     value = value * RANGE.length;
209                     final int d = (int) value;
210                     value = value - d;
211                     data[i] = RANGE[d];
212                 }
213                 out.write(data, 0, end);
214                 out.flush();
215 
216                 remaining = remaining - end;
217             }
218             out.close();
219 
220         } // writeTo
221 
222     } // class RandomEntity
223 
224 
225 } // class RandomHandler