/
HttpResponse.java
313 lines (271 loc) · 7.95 KB
/
HttpResponse.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
/*
* Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
/*
* $Id$
*/
package com.sun.ts.tests.common.webclient.http;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpMethodBase;
import org.apache.commons.httpclient.HttpState;
import org.apache.commons.httpclient.HttpVersion;
import com.sun.ts.tests.common.webclient.Util;
/**
* This class represents an HTTP response from the server.
*/
public class HttpResponse {
/**
* Default encoding based on Servlet Specification
*/
private static final String DEFAULT_ENCODING = "ISO-8859-1";
/**
* Content-Type header
*/
private static final String CONTENT_TYPE = "Content-Type";
/**
* Wrapped HttpMethod used to pull response info from.
*/
private HttpMethod _method = null;
/**
* HttpState obtained after execution of request
*/
private HttpState _state = null;
/**
* Charset encoding returned in the response
*/
private String _encoding = DEFAULT_ENCODING;
/**
* The response body. Initialized after first call to one of the
* getResponseBody methods and cached for subsequent calls.
*/
private String _responseBody = null;
/**
* Host name used for processing request
*/
private String _host = null;
/**
* Port number used for processing request
*/
private int _port;
/**
* Issecure
*/
private boolean _isSecure;
/** Creates new HttpResponse */
public HttpResponse(String host, int port, boolean isSecure,
HttpMethod method, HttpState state) {
_host = host;
_port = port;
_isSecure = isSecure;
_method = method;
_state = state;
}
/*
* public methods
* ========================================================================
*/
/**
* Returns the HTTP status code returned by the server
*
* @return HTTP status code
*/
public String getStatusCode() {
return Integer.toString(_method.getStatusCode());
}
/**
* Returns the HTTP reason-phrase returned by the server
*
* @return HTTP reason-phrase
*/
public String getReasonPhrase() {
return _method.getStatusText();
}
/**
* Returns the headers received in the response from the server.
*
* @return response headers
*/
public Header[] getResponseHeaders() {
return _method.getResponseHeaders();
}
/**
* Returns the headers designated by the name provided.
*
* @return response headers
*/
public Header[] getResponseHeaders(String headerName) {
return _method.getResponseHeaders(headerName);
}
/**
* Returns the response header designated by the name provided.
*
* @return a specfic response header or null if the specified header doesn't
* exist.
*/
public Header getResponseHeader(String headerName) {
return _method.getResponseHeader(headerName);
}
/**
* Returns the response body as a byte array using the charset specified in
* the server's response.
*
* @return response body as an array of bytes.
*/
public byte[] getResponseBodyAsBytes() throws IOException {
return getEncodedResponse().getBytes();
}
/**
* Returns the response as bytes (no encoding is performed by client.
*
* @return the raw response bytes
* @throws IOException
* if an error occurs reading from server
*/
public byte[] getResponseBodyAsRawBytes() throws IOException {
return _method.getResponseBody();
}
/**
* Returns the response body as a string using the charset specified in the
* server's response.
*
* @return response body as a String
*/
public String getResponseBodyAsString() throws IOException {
return getEncodedResponse();
}
/**
* Returns the response body of the server without being encoding by the
* client.
*
* @return an unecoded String representation of the response
* @throws IOException
* if an error occurs reading from the server
*/
public String getResponseBodyAsRawString() throws IOException {
return _method.getResponseBodyAsString();
}
/**
* Returns the response body as an InputStream using the encoding specified in
* the server's response.
*
* @return response body as an InputStream
*/
public InputStream getResponseBodyAsStream() throws IOException {
return new ByteArrayInputStream(getEncodedResponse().getBytes());
}
/**
* Returns the response body as an InputStream without any encoding applied by
* the client.
*
* @return an InputStream to read the response
* @throws IOException
* if an error occurs reading from the server
*/
public InputStream getResponseBodyAsRawStream() throws IOException {
return _method.getResponseBodyAsStream();
}
/**
* Returns the charset encoding for this response.
*
* @return charset encoding
*/
public String getResponseEncoding() {
Header content = _method.getResponseHeader(CONTENT_TYPE);
if (content != null) {
String headerVal = content.getValue();
int idx = headerVal.indexOf(";charset=");
if (idx > -1) {
// content encoding included in response
_encoding = headerVal.substring(idx + 9);
}
}
return _encoding;
}
/**
* Returns the post-request state.
*
* @return an HttpState object
*/
public HttpState getState() {
return _state;
}
/**
* Displays a String representation of the response.
*
* @return string representation of response
*/
public String toString() {
StringBuffer sb = new StringBuffer(255);
sb.append("[RESPONSE STATUS LINE] -> ");
sb.append(((HttpMethodBase) _method).getParams().getVersion()
.equals(HttpVersion.HTTP_1_1) ? "HTTP/1.1 " : "HTTP/1.0 ");
sb.append(_method.getStatusCode()).append(' ');
sb.append(_method.getStatusText()).append('\n');
Header[] headers = _method.getResponseHeaders();
if (headers != null && headers.length != 0) {
for (int i = 0; i < headers.length; i++) {
sb.append(" [RESPONSE HEADER] -> ");
sb.append(headers[i].toExternalForm()).append('\n');
}
}
String resBody;
try {
resBody = _method.getResponseBodyAsString();
} catch (IOException ioe) {
resBody = "UNEXECTED EXCEPTION: " + ioe.toString();
}
if (resBody != null && resBody.length() != 0) {
sb.append("------ [RESPONSE BODY] ------\n");
sb.append(resBody);
sb.append("\n-----------------------------\n\n");
}
return sb.toString();
}
/*
* Eventually they need to come from _method
*/
public String getHost() {
return _host;
}
public int getPort() {
return _port;
}
public String getProtocol() {
return _isSecure ? "https" : "http";
}
public String getPath() {
return _method.getPath();
}
/*
* Private Methods
* ==========================================================================
*/
/**
* Returns the response body using the encoding returned in the response.
*
* @return encoded response String.
*/
private String getEncodedResponse() throws IOException {
if (_responseBody == null) {
_responseBody = Util.getEncodedStringFromStream(
_method.getResponseBodyAsStream(), getResponseEncoding());
}
return _responseBody;
}
}