org.apache.coyote.Response Java Examples

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) 
    throws IOException {

    int length = chunk.getLength();
    if (useSocketBuffer) {
        socketBuffer.append(chunk.getBuffer(), chunk.getStart(), 
                            length);
    } else {
        outputStream.write(chunk.getBuffer(), chunk.getStart(), 
                           length);
    }
    byteCount += chunk.getLength();
    return chunk.getLength();
}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) 
    throws IOException {

    int len = chunk.getLength();
    int start = chunk.getStart();
    byte[] b = chunk.getBuffer();
    while (len > 0) {
        int thisTime = len;
        if (bbuf.position() == bbuf.capacity()) {
            flushBuffer();
        }
        if (thisTime > bbuf.capacity() - bbuf.position()) {
            thisTime = bbuf.capacity() - bbuf.position();
        }
        bbuf.put(b, start, thisTime);
        len = len - thisTime;
        start = start + thisTime;
    }
    byteCount += chunk.getLength();
    return chunk.getLength();
}
 

protected Http11OutputBuffer(Response response, int headerBufferSize, boolean sendReasonPhrase) {

        this.response = response;
        this.sendReasonPhrase = sendReasonPhrase;

        headerBuffer = ByteBuffer.allocate(headerBufferSize);

        filterLibrary = new OutputFilter[0];
        activeFilters = new OutputFilter[0];
        lastActiveFilter = -1;

        responseFinished = false;

        outputStreamOutputBuffer = new SocketOutputBuffer();

        if (sendReasonPhrase) {
            // Cause loading of HttpMessages
            HttpMessages.getInstance(response.getLocale()).getMessage(200);
        }
    }
 

/**
 * Default constructor.
 */
public InternalAprOutputBuffer(Response response, int headerBufferSize) {

    this.response = response;

    buf = new byte[headerBufferSize];
    if (headerBufferSize < (8 * 1024)) {
        bbuf = ByteBuffer.allocateDirect(6 * 1500);
    } else {
        bbuf = ByteBuffer.allocateDirect((headerBufferSize / 1500 + 1) * 1500);
    }

    outputStreamOutputBuffer = new SocketOutputBuffer();

    filterLibrary = new OutputFilter[0];
    activeFilters = new OutputFilter[0];
    lastActiveFilter = -1;

    committed = false;
    finished = false;

    // Cause loading of HttpMessages
    HttpMessages.getInstance(response.getLocale()).getMessage(200);

}
 

/**
 * Write the contents of a byte chunk.
 * 
 * @param chunk byte chunk
 * @return number of bytes written
 * @throws IOException an underlying I/O error occurred
 */
@Override
public int doWrite(ByteChunk chunk, Response res) 
    throws IOException {

    if (!committed) {

        // Send the connector a request for commit. The connector should
        // then validate the headers, send them (using sendHeaders) and 
        // set the filters accordingly.
        response.action(ActionCode.COMMIT, null);

    }

    if (lastActiveFilter == -1)
        return outputStreamOutputBuffer.doWrite(chunk, res);
    else
        return activeFilters[lastActiveFilter].doWrite(chunk, res);

}
 

/**
 * Default constructor.
 */
public InternalAprOutputBuffer(Response response, int headerBufferSize) {

    this.response = response;

    buf = new byte[headerBufferSize];
    if (headerBufferSize < (8 * 1024)) {
        bbuf = ByteBuffer.allocateDirect(6 * 1500);
    } else {
        bbuf = ByteBuffer.allocateDirect((headerBufferSize / 1500 + 1) * 1500);
    }

    outputStreamOutputBuffer = new SocketOutputBuffer();

    filterLibrary = new OutputFilter[0];
    activeFilters = new OutputFilter[0];
    lastActiveFilter = -1;

    committed = false;
    finished = false;

    // Cause loading of HttpMessages
    HttpMessages.getInstance(response.getLocale()).getMessage(200);

}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) throws IOException {
    try {
        int len = chunk.getLength();
        int start = chunk.getStart();
        byte[] b = chunk.getBuffer();
        addToBB(b, start, len);
        byteCount += chunk.getLength();
        return chunk.getLength();
    } catch (IOException ioe) {
        response.action(ActionCode.CLOSE_NOW, ioe);
        // Re-throw
        throw ioe;
    }
}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) throws IOException {
    try {
        int length = chunk.getLength();
        if (useSocketBuffer) {
            socketBuffer.append(chunk.getBuffer(), chunk.getStart(),
                                length);
        } else {
            outputStream.write(chunk.getBuffer(), chunk.getStart(),
                               length);
        }
        byteCount += chunk.getLength();
        return chunk.getLength();
    } catch (IOException ioe) {
        response.action(ActionCode.CLOSE_NOW, ioe);
        // Re-throw
        throw ioe;
    }
}
 

/**
 * Write the contents of a byte chunk.
 * 
 * @param chunk byte chunk
 * @return number of bytes written
 * @throws IOException an underlying I/O error occurred
 */
@Override
public int doWrite(ByteChunk chunk, Response res) 
    throws IOException {

    if (!committed) {

        // Send the connector a request for commit. The connector should
        // then validate the headers, send them (using sendHeaders) and 
        // set the filters accordingly.
        response.action(ActionCode.COMMIT, null);

    }

    if (lastActiveFilter == -1)
        return outputStreamOutputBuffer.doWrite(chunk, res);
    else
        return activeFilters[lastActiveFilter].doWrite(chunk, res);

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    int result = -1;

    if (contentLength >= 0) {
        if (remaining > 0) {
            result = chunk.getLength();
            if (result > remaining) {
                // The chunk is longer than the number of bytes remaining
                // in the body; changing the chunk length to the number
                // of bytes remaining
                chunk.setBytes(chunk.getBytes(), chunk.getStart(), 
                               (int) remaining);
                result = (int) remaining;
                remaining = 0;
            } else {
                remaining = remaining - result;
            }
            buffer.doWrite(chunk, res);
        } else {
            // No more bytes left to be written : return -1 and clear the 
            // buffer
            chunk.recycle();
            result = -1;
        }
    } else {
        // If no content length was set, just write the bytes
        buffer.doWrite(chunk, res);
        result = chunk.getLength();
    }

    return result;

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    return chunk.getLength();

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {
    if (compressionStream == null) {
        compressionStream = new FlushableGZIPOutputStream(fakeOutputStream);
    }
    compressionStream.write(chunk.getBytes(), chunk.getStart(), 
                            chunk.getLength());
    return chunk.getLength();
}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    int result = chunk.getLength();

    if (result <= 0) {
        return 0;
    }

    // Calculate chunk header
    int pos = 7;
    int current = result;
    while (current > 0) {
        int digit = current % 16;
        current = current / 16;
        chunkLength[pos--] = HexUtils.getHex(digit);
    }
    chunkHeader.setBytes(chunkLength, pos + 1, 9 - pos);
    buffer.doWrite(chunkHeader, res);

    buffer.doWrite(chunk, res);

    chunkHeader.setBytes(chunkLength, 8, 2);
    buffer.doWrite(chunkHeader, res);

    return result;

}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) 
    throws IOException {

    int len = chunk.getLength();
    int start = chunk.getStart();
    byte[] b = chunk.getBuffer();
    addToBB(b, start, len);
    byteCount += chunk.getLength();
    return chunk.getLength();
}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    if (!response.isCommitted()) {
        // Validate and write response headers
        try {
            prepareResponse();
        } catch (IOException e) {
            setErrorState(ErrorState.CLOSE_NOW, e);
        }
    }

    if (!swallowResponse) {
        int len = chunk.getLength();
        // 4 - hardcoded, byte[] marshaling overhead
        // Adjust allowed size if packetSize != default (Constants.MAX_PACKET_SIZE)
        int chunkSize = Constants.MAX_SEND_SIZE + packetSize - Constants.MAX_PACKET_SIZE;
        int off = 0;
        while (len > 0) {
            int thisTime = len;
            if (thisTime > chunkSize) {
                thisTime = chunkSize;
            }
            len -= thisTime;
            responseMessage.reset();
            responseMessage.appendByte(Constants.JK_AJP13_SEND_BODY_CHUNK);
            responseMessage.appendBytes(chunk.getBytes(), chunk.getOffset() + off, thisTime);
            responseMessage.end();
            output(responseMessage.getBuffer(), 0, responseMessage.getLen());

            off += thisTime;
        }

        bytesWritten += chunk.getLength();
    }
    return chunk.getLength();
}
 

private static HttpHeaders createTomcatHttpHeaders(HttpServletResponse response) {
	ResponseFacade responseFacade = getResponseFacade(response);
	org.apache.catalina.connector.Response connectorResponse = (org.apache.catalina.connector.Response)
			ReflectionUtils.getField(COYOTE_RESPONSE_FIELD, responseFacade);
	Assert.state(connectorResponse != null, "No Tomcat connector response");
	Response tomcatResponse = connectorResponse.getCoyoteResponse();
	TomcatHeadersAdapter headers = new TomcatHeadersAdapter(tomcatResponse.getMimeHeaders());
	return new HttpHeaders(headers);
}
 

private static ResponseHeaders convertResponse(Response coyoteRes) {
    final ResponseHeadersBuilder headers = ResponseHeaders.builder();
    headers.status(coyoteRes.getStatus());

    final String contentType = coyoteRes.getContentType();
    if (contentType != null && !contentType.isEmpty()) {
        headers.set(HttpHeaderNames.CONTENT_TYPE, contentType);
    }

    final long contentLength = coyoteRes.getBytesWritten(true); // 'true' will trigger flush.
    final String method = coyoteRes.getRequest().method().toString();
    if (!"HEAD".equals(method)) {
        headers.setLong(HttpHeaderNames.CONTENT_LENGTH, contentLength);
    }

    final MimeHeaders cHeaders = coyoteRes.getMimeHeaders();
    final int numHeaders = cHeaders.size();
    for (int i = 0; i < numHeaders; i++) {
        final AsciiString name = toHeaderName(cHeaders.getName(i));
        if (name == null) {
            continue;
        }

        final String value = toHeaderValue(cHeaders.getValue(i));
        if (value == null) {
            continue;
        }

        headers.add(name.toLowerCase(), value);
    }

    return headers.build();
}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    int result = chunk.getLength();

    if (result <= 0) {
        return 0;
    }

    // Calculate chunk header
    int pos = 7;
    int current = result;
    while (current > 0) {
        int digit = current % 16;
        current = current / 16;
        chunkLength[pos--] = HexUtils.getHex(digit);
    }
    chunkHeader.setBytes(chunkLength, pos + 1, 9 - pos);
    buffer.doWrite(chunkHeader, res);

    buffer.doWrite(chunk, res);

    chunkHeader.setBytes(chunkLength, 8, 2);
    buffer.doWrite(chunkHeader, res);

    return result;

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    int result = -1;

    if (contentLength >= 0) {
        if (remaining > 0) {
            result = chunk.getLength();
            if (result > remaining) {
                // The chunk is longer than the number of bytes remaining
                // in the body; changing the chunk length to the number
                // of bytes remaining
                chunk.setBytes(chunk.getBytes(), chunk.getStart(), 
                               (int) remaining);
                result = (int) remaining;
                remaining = 0;
            } else {
                remaining = remaining - result;
            }
            buffer.doWrite(chunk, res);
        } else {
            // No more bytes left to be written : return -1 and clear the 
            // buffer
            chunk.recycle();
            result = -1;
        }
    } else {
        // If no content length was set, just write the bytes
        buffer.doWrite(chunk, res);
        result = chunk.getLength();
    }

    return result;

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    return chunk.getLength();

}
 

/**
 * Write some bytes.
 * 
 * @return number of bytes written by the filter
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {
    if (compressionStream == null) {
        compressionStream = new FlushableGZIPOutputStream(fakeOutputStream);
    }
    compressionStream.write(chunk.getBytes(), chunk.getStart(), 
                            chunk.getLength());
    return chunk.getLength();
}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res) throws IOException {
    try {
        int len = chunk.getLength();
        int start = chunk.getStart();
        byte[] b = chunk.getBuffer();
        while (len > 0) {
            int thisTime = len;
            if (bbuf.position() == bbuf.capacity()) {
                flushBuffer();
            }
            if (thisTime > bbuf.capacity() - bbuf.position()) {
                thisTime = bbuf.capacity() - bbuf.position();
            }
            bbuf.put(b, start, thisTime);
            len = len - thisTime;
            start = start + thisTime;
        }
        byteCount += chunk.getLength();
        return chunk.getLength();
    } catch (IOException ioe) {
        response.action(ActionCode.CLOSE_NOW, ioe);
        // Re-throw
        throw ioe;
    }
}
 

@Test
public void testFlushingWithGzip() throws Exception {
    // set up response, InternalOutputBuffer, and ByteArrayOutputStream
    Response res = new Response();
    TesterOutputBuffer tob = new TesterOutputBuffer(res, 8 * 1024);
    res.setOutputBuffer(tob);

    // set up GzipOutputFilter to attach to the TesterOutputBuffer
    GzipOutputFilter gf = new GzipOutputFilter();
    tob.addFilter(gf);
    tob.addActiveFilter(gf);

    // write a chunk out
    byte[] d = "Hello there tomcat developers, there is a bug in JDK".getBytes();
    ByteBuffer bb = ByteBuffer.wrap(d);
    tob.doWrite(bb);

    // flush the InternalOutputBuffer
    tob.flush();

    // read from the ByteArrayOutputStream to find out what's being written
    // out (flushed)
    byte[] dataFound = tob.toByteArray();

    // find out what's expected by writing to GZIPOutputStream and close it
    // (to force flushing)
    ByteArrayOutputStream gbos = new ByteArrayOutputStream(1024);
    GZIPOutputStream gos = new GZIPOutputStream(gbos);
    gos.write(d);
    gos.close();

    // read the expected data
    byte[] dataExpected = gbos.toByteArray();

    // most of the data should have been flushed out
    Assert.assertTrue(dataFound.length >= (dataExpected.length - 20));
}
 

private static HttpHeaders createTomcatHttpHeaders(HttpServletResponse response) {
	ResponseFacade responseFacade = getResponseFacade(response);
	org.apache.catalina.connector.Response connectorResponse = (org.apache.catalina.connector.Response)
			ReflectionUtils.getField(COYOTE_RESPONSE_FIELD, responseFacade);
	Assert.state(connectorResponse != null, "No Tomcat connector response");
	Response tomcatResponse = connectorResponse.getCoyoteResponse();
	TomcatHeadersAdapter headers = new TomcatHeadersAdapter(tomcatResponse.getMimeHeaders());
	return new HttpHeaders(headers);
}
 

/**
 * Write chunk.
 */
@Override
public int doWrite(ByteChunk chunk, Response res)
    throws IOException {

    if (!response.isCommitted()) {
        // Validate and write response headers
        try {
            prepareResponse();
        } catch (IOException e) {
            setErrorState(ErrorState.CLOSE_NOW, e);
        }
    }

    if (!swallowResponse) {
        try {
            int len = chunk.getLength();
            // 4 - hardcoded, byte[] marshaling overhead
            // Adjust allowed size if packetSize != default (Constants.MAX_PACKET_SIZE)
            int chunkSize = Constants.MAX_SEND_SIZE + packetSize - Constants.MAX_PACKET_SIZE;
            int off = 0;
            while (len > 0) {
                int thisTime = len;
                if (thisTime > chunkSize) {
                    thisTime = chunkSize;
                }
                len -= thisTime;
                responseMessage.reset();
                responseMessage.appendByte(Constants.JK_AJP13_SEND_BODY_CHUNK);
                responseMessage.appendBytes(chunk.getBytes(), chunk.getOffset() + off, thisTime);
                responseMessage.end();
                output(responseMessage.getBuffer(), 0, responseMessage.getLen());

                off += thisTime;
            }

            bytesWritten += chunk.getLength();
        } catch (IOException ioe) {
            response.action(ActionCode.CLOSE_NOW, ioe);
            // Re-throw
            throw ioe;
        }
    }
    return chunk.getLength();
}
 

/**
 * Default constructor.
 */
public InternalOutputBuffer(Response response, int headerBufferSize) {

    this.response = response;

    buf = new byte[headerBufferSize];

    outputStreamOutputBuffer = new OutputStreamOutputBuffer();

    filterLibrary = new OutputFilter[0];
    activeFilters = new OutputFilter[0];
    lastActiveFilter = -1;

    socketBuffer = new ByteChunk();
    socketBuffer.setByteOutputChannel(this);

    committed = false;
    finished = false;

}
 

/**
 * Default constructor.
 */
public InternalNioOutputBuffer(Response response, int headerBufferSize) {

    this.response = response;

    buf = new byte[headerBufferSize];

    outputStreamOutputBuffer = new SocketOutputBuffer();

    filterLibrary = new OutputFilter[0];
    activeFilters = new OutputFilter[0];
    lastActiveFilter = -1;

    committed = false;
    finished = false;

    // Cause loading of HttpMessages
    HttpMessages.getInstance(response.getLocale()).getMessage(200);

}
 

/**
 * Some filters need additional parameters from the response. All the 
 * necessary reading can occur in that method, as this method is called
 * after the response header processing is complete.
 */
@Override
public void setResponse(Response response) {
    contentLength = response.getContentLengthLong();
    remaining = contentLength;
}
 

/**
 * Test the interaction betwen gzip and flushing. The idea is to: 1. create
 * a internal output buffer, response, and attach an active gzipoutputfilter
 * to the output buffer 2. set the output stream of the internal buffer to
 * be a ByteArrayOutputStream so we can inspect the output bytes 3. write a
 * chunk out using the gzipoutputfilter and invoke a flush on the
 * InternalOutputBuffer 4. read from the ByteArrayOutputStream to find out
 * what's being written out (flushed) 5. find out what's expected by wrting
 * to GZIPOutputStream and close it (to force flushing) 6. Compare the size
 * of the two arrays, they should be close (instead of one being much
 * shorter than the other one)
 *
 * @throws Exception
 */
@Test
public void testFlushingWithGzip() throws Exception {
    // set up response, InternalOutputBuffer, and ByteArrayOutputStream
    Response res = new Response();
    InternalOutputBuffer iob = new InternalOutputBuffer(res, 8 * 1024);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    iob.outputStream = bos;
    res.setOutputBuffer(iob);

    // set up GzipOutputFilter to attach to the InternalOutputBuffer
    GzipOutputFilter gf = new GzipOutputFilter();
    iob.addFilter(gf);
    iob.addActiveFilter(gf);

    // write a chunk out
    ByteChunk chunk = new ByteChunk(1024);
    byte[] d = "Hello there tomcat developers, there is a bug in JDK".getBytes();
    chunk.append(d, 0, d.length);
    iob.doWrite(chunk, res);

    // flush the InternalOutputBuffer
    iob.flush();

    // read from the ByteArrayOutputStream to find out what's being written
    // out (flushed)
    byte[] dataFound = bos.toByteArray();

    // find out what's expected by wrting to GZIPOutputStream and close it
    // (to force flushing)
    ByteArrayOutputStream gbos = new ByteArrayOutputStream(1024);
    GZIPOutputStream gos = new GZIPOutputStream(gbos);
    gos.write(d);
    gos.close();

    // read the expected data
    byte[] dataExpected = gbos.toByteArray();

    // most of the data should have been flushed out
    assertTrue(dataFound.length >= (dataExpected.length - 20));
}
 

/**
 * Test the interaction betwen gzip and flushing. The idea is to: 1. create
 * a internal output buffer, response, and attach an active gzipoutputfilter
 * to the output buffer 2. set the output stream of the internal buffer to
 * be a ByteArrayOutputStream so we can inspect the output bytes 3. write a
 * chunk out using the gzipoutputfilter and invoke a flush on the
 * InternalOutputBuffer 4. read from the ByteArrayOutputStream to find out
 * what's being written out (flushed) 5. find out what's expected by wrting
 * to GZIPOutputStream and close it (to force flushing) 6. Compare the size
 * of the two arrays, they should be close (instead of one being much
 * shorter than the other one)
 *
 * @throws Exception
 */
@Test
public void testFlushingWithGzip() throws Exception {
    // set up response, InternalOutputBuffer, and ByteArrayOutputStream
    Response res = new Response();
    InternalOutputBuffer iob = new InternalOutputBuffer(res, 8 * 1024);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    iob.outputStream = bos;
    res.setOutputBuffer(iob);

    // set up GzipOutputFilter to attach to the InternalOutputBuffer
    GzipOutputFilter gf = new GzipOutputFilter();
    iob.addFilter(gf);
    iob.addActiveFilter(gf);

    // write a chunk out
    ByteChunk chunk = new ByteChunk(1024);
    byte[] d = "Hello there tomcat developers, there is a bug in JDK".getBytes();
    chunk.append(d, 0, d.length);
    iob.doWrite(chunk, res);

    // flush the InternalOutputBuffer
    iob.flush();

    // read from the ByteArrayOutputStream to find out what's being written
    // out (flushed)
    byte[] dataFound = bos.toByteArray();

    // find out what's expected by wrting to GZIPOutputStream and close it
    // (to force flushing)
    ByteArrayOutputStream gbos = new ByteArrayOutputStream(1024);
    GZIPOutputStream gos = new GZIPOutputStream(gbos);
    gos.write(d);
    gos.close();

    // read the expected data
    byte[] dataExpected = gbos.toByteArray();

    // most of the data should have been flushed out
    assertTrue(dataFound.length >= (dataExpected.length - 20));
}