Java Source Code: org.apache.commons.httpclient.server.SimpleResponse


   1: /*
   2:  * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/test/org/apache/commons/httpclient/server/SimpleResponse.java,v 1.8 2004/11/13 12:21:28 olegk Exp $
   3:  * $Revision: 480424 $
   4:  * $Date: 2006-11-29 06:56:49 +0100 (Wed, 29 Nov 2006) $
   5:  *
   6:  * ====================================================================
   7:  *
   8:  *  Licensed to the Apache Software Foundation (ASF) under one or more
   9:  *  contributor license agreements.  See the NOTICE file distributed with
  10:  *  this work for additional information regarding copyright ownership.
  11:  *  The ASF licenses this file to You under the Apache License, Version 2.0
  12:  *  (the "License"); you may not use this file except in compliance with
  13:  *  the License.  You may obtain a copy of the License at
  14:  *
  15:  *      http://www.apache.org/licenses/LICENSE-2.0
  16:  *
  17:  *  Unless required by applicable law or agreed to in writing, software
  18:  *  distributed under the License is distributed on an "AS IS" BASIS,
  19:  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20:  *  See the License for the specific language governing permissions and
  21:  *  limitations under the License.
  22:  * ====================================================================
  23:  *
  24:  * This software consists of voluntary contributions made by many
  25:  * individuals on behalf of the Apache Software Foundation.  For more
  26:  * information on the Apache Software Foundation, please see
  27:  * <http://www.apache.org/>.
  28:  *
  29:  */
  30: 
  31: package org.apache.commons.httpclient.server;
  32: 
  33: import java.io.ByteArrayInputStream;
  34: import java.io.ByteArrayOutputStream;
  35: import java.io.IOException;
  36: import java.io.InputStream;
  37: import java.io.UnsupportedEncodingException;
  38: import java.util.Iterator;
  39: 
  40: import org.apache.commons.httpclient.ChunkedInputStream;
  41: import org.apache.commons.httpclient.ContentLengthInputStream;
  42: import org.apache.commons.httpclient.Header;
  43: import org.apache.commons.httpclient.HeaderElement;
  44: import org.apache.commons.httpclient.HeaderGroup;
  45: import org.apache.commons.httpclient.HttpStatus;
  46: import org.apache.commons.httpclient.HttpVersion;
  47: import org.apache.commons.httpclient.NameValuePair;
  48: import org.apache.commons.httpclient.StatusLine;
  49: 
  50: /**
  51:  * A generic HTTP response.
  52:  * 
  53:  * @author Christian Kohlschuetter
  54:  * @author Oleg Kalnichevski
  55:  */
  56:	  public class SimpleResponse {
  57:    
  58:    public static final String DEFAULT_CONTENT_CHARSET = "ISO-8859-1";
  59:    
  60:    private HttpVersion ver = HttpVersion.HTTP_1_1;
  61:    private int statuscode = HttpStatus.SC_OK;
  62:    private String phrase = HttpStatus.getStatusText(HttpStatus.SC_OK);
  63:    private HeaderGroup headers = new HeaderGroup();
  64:    private InputStream entity = null;
  65:
  66:	      public SimpleResponse() {
  67:        super();
  68:    }
  69:
  70:    public SimpleResponse(
  71:            final StatusLine statusline, 
  72:            final Header[] headers, 
  73:            final InputStream content) 
  74:	              throws IOException {
  75:        super();
  76:	          if (statusline == null) {
  77:            throw new IllegalArgumentException("Status line may not be null");
  78:        }
  79:        setStatusLine(HttpVersion.parse(statusline.getHttpVersion()),
  80:                statusline.getStatusCode(), statusline.getReasonPhrase());
  81:        setHeaders(headers);
  82:	          if (content != null) {
  83:            InputStream in = content;
  84:            Header contentLength = this.headers.getFirstHeader("Content-Length");
  85:            Header transferEncoding = this.headers.getFirstHeader("Transfer-Encoding");
  86:
  87:	              if (transferEncoding != null) {
  88:	                  if (transferEncoding.getValue().indexOf("chunked") != -1) {
  89:                    in = new ChunkedInputStream(in);
  90:                }
  91:            } else if (contentLength != null) {
  92:                long len = getContentLength();
  93:	                  if (len >= 0) {
  94:                    in = new ContentLengthInputStream(in, len);
  95:                }
  96:            }
  97:            this.entity = in;
  98:        }
  99:    }
 100:
 101:
 102:	      public void setStatusLine(final HttpVersion ver, int statuscode, final String phrase) {
 103:	          if (ver == null) {
 104:            throw new IllegalArgumentException("HTTP version may not be null");
 105:        }
 106:	          if (statuscode <= 0) {
 107:            throw new IllegalArgumentException("Status code may not be negative or zero");
 108:        }
 109:        this.ver = ver;
 110:        this.statuscode = statuscode;
 111:	          if (phrase != null) {
 112:            this.phrase = phrase;
 113:        } else {
 114:            this.phrase = HttpStatus.getStatusText(statuscode);
 115:        }
 116:    }
 117:
 118:	      public void setStatusLine(final HttpVersion ver, int statuscode) {
 119:        setStatusLine(ver, statuscode, null);
 120:    }
 121:
 122:	      public String getPhrase() {
 123:        return this.phrase;
 124:    }
 125:
 126:	      public int getStatuscode() {
 127:        return this.statuscode;
 128:    }
 129:
 130:	      public HttpVersion getHttpVersion() {
 131:        return this.ver;
 132:    }
 133:
 134:	      public String getStatusLine() {
 135:        StringBuffer buffer = new StringBuffer();
 136:        buffer.append(this.ver);
 137:        buffer.append(' ');
 138:        buffer.append(this.statuscode);
 139:	          if (this.phrase != null) {
 140:            buffer.append(' ');
 141:            buffer.append(this.phrase);
 142:        }
 143:        return buffer.toString();
 144:    }
 145:
 146:	      public boolean containsHeader(final String name) {
 147:        return this.headers.containsHeader(name);
 148:    }
 149:
 150:	      public Header[] getHeaders() {
 151:        return this.headers.getAllHeaders();
 152:    }
 153:
 154:	      public Header getFirstHeader(final String name) {
 155:        return this.headers.getFirstHeader(name);
 156:    }
 157:
 158:	      public void removeHeaders(final String s) {
 159:	          if (s == null) {
 160:            return;
 161:        }
 162:        Header[] headers = this.headers.getHeaders(s);
 163:	          for (int i = 0; i < headers.length; i++) {
 164:            this.headers.removeHeader(headers[i]);
 165:        }
 166:    }
 167:
 168:	      public void addHeader(final Header header) {
 169:	          if (header == null) {
 170:            return;
 171:        }
 172:        this.headers.addHeader(header);
 173:    }
 174:
 175:	      public void setHeader(final Header header) {
 176:	          if (header == null) {
 177:            return;
 178:        }
 179:        removeHeaders(header.getName());
 180:        addHeader(header);
 181:    }
 182:
 183:	      public void setHeaders(final Header[] headers) {
 184:	          if (headers == null) {
 185:            return;
 186:        }
 187:        this.headers.setHeaders(headers);
 188:    }
 189:
 190:	      public Iterator getHeaderIterator() {
 191:        return this.headers.getIterator();
 192:    }
 193:    
 194:	      public String getCharset() {
 195:        String charset = DEFAULT_CONTENT_CHARSET;
 196:        Header contenttype = this.headers.getFirstHeader("Content-Type");
 197:	          if (contenttype != null) {
 198:            HeaderElement values[] = contenttype.getElements();
 199:	              if (values.length == 1) {
 200:                NameValuePair param = values[0].getParameterByName("charset");
 201:	                  if (param != null) {
 202:                    charset = param.getValue();
 203:                }
 204:            }
 205:        }
 206:        return charset;
 207:    }
 208:
 209:	      public long getContentLength() {
 210:        Header contentLength = this.headers.getFirstHeader("Content-Length");
 211:	          if (contentLength != null) {
 212:	              try {
 213:                return Long.parseLong(contentLength.getValue());
 214:            } catch (NumberFormatException e) {
 215:                return -1;
 216:            }
 217:        } else {
 218:            return -1;
 219:        }
 220:    }
 221:    
 222:	      public void setBodyString(final String string) {
 223:	          if (string != null) {
 224:            byte[] raw = null;
 225:	              try {
 226:                raw = string.getBytes(DEFAULT_CONTENT_CHARSET);
 227:            } catch (UnsupportedEncodingException e) {
 228:                raw = string.getBytes();
 229:            }
 230:            this.entity = new ByteArrayInputStream(raw);
 231:	              if (!containsHeader("Content-Type")) {
 232:                setHeader(new Header("Content-Type", "text/plain"));
 233:            }
 234:            setHeader(new Header("Content-Length", Long.toString(raw.length)));
 235:        } else {
 236:            this.entity = null;
 237:        }
 238:    }
 239:    
 240:	      public void setBody(final InputStream instream) {
 241:        this.entity = instream;
 242:    }
 243:    
 244:	      public InputStream getBody() {
 245:        return this.entity;
 246:    }
 247:    
 248:	      public byte[] getBodyBytes() throws IOException {
 249:        InputStream in = getBody();
 250:	          if (in != null) {
 251:            byte[] tmp = new byte[4096];
 252:            int bytesRead = 0;
 253:            ByteArrayOutputStream buffer = new ByteArrayOutputStream(1024);
 254:	              while ((bytesRead = in.read(tmp)) != -1) {
 255:                buffer.write(tmp, 0, bytesRead);
 256:            }
 257:            return buffer.toByteArray();
 258:        } else {
 259:            return null;
 260:        }
 261:    }
 262:    
 263:	      public String getBodyString() throws IOException {
 264:        byte[] raw = getBodyBytes();
 265:	          if (raw != null) {
 266:            return new String(raw, getCharset());
 267:        } else {
 268:            return null;
 269:        }
 270:    }
 271:}