private void loadCompleteContent(final HttpServletRequestImpl request, final HttpServletResponseImpl response, final File file) throws IOException { response.setContentType(mimeTypeMapping.getMimeTypeByExtension(FileUtilities.getExtension(file.getName()))); response.setStatus(HttpServletResponse.STATUS_OK); response.setContentLength(file.length()); response.getHeaders().setHeader(Headers.HEADER_ACCEPT_RANGES, "bytes"); response.flushHeaders(); if (!request.getMethod().equals(HttpServletRequest.METHOD_HEAD)) { InputStream fileInputStream = new FileInputStream(file); try { response.serveStream(fileInputStream); } finally { IOUtilities.closeSilently(fileInputStream); } } response.flush(); }
/** * Creates and returns a response outputStream of the socket. * * @param socket * @return */ public HttpServletResponseImpl createFromSocket(final Socket socket) throws IOException { return new HttpServletResponseImpl(headersSerializer, cookieHeaderSerializer, streamHelper, socket.getOutputStream()); } }
private void flushHeadersIfPossible() throws IOException { if (!response.isCommitted()) { response.flushHeaders(); } }
private void sendRedirectToDirectorySlashedPath(final HttpServletResponseImpl response, final String originalPath) throws IOException { response.setStatus(HttpServletResponse.STATUS_MOVED_PERMANENTLY); response.getHeaders().setHeader(Headers.HEADER_LOCATION, originalPath + "/"); response.flush(); }
private void serveFile(final HttpServletResponse response, final File file) throws IOException { response.setContentLength(file.length()); ((HttpServletResponseImpl) response).flushHeaders(); InputStream inputStream = new FileInputStream(file); try { ((HttpServletResponseImpl) response).serveStream(inputStream); ((HttpServletResponseImpl) response).flush(); } finally { IOUtilities.closeSilently(inputStream); } } }
/** * {@inheritDoc} */ @Override public void load(final String path, final HttpServletRequestImpl request, final HttpServletResponseImpl response) { String assetPath = getAssetPath(path); InputStream inputStream = null; try { inputStream = getInputStream(assetPath); response.setStatus(HttpServletResponse.STATUS_OK); // This must be done in a separate try catch block as some assets do not have a FD try (AssetFileDescriptor afd = assetManager.openFd(assetPath)) { response.setContentLength(afd.getLength()); } catch (IOException e) { // There is no asset description or we can't read the length of the asset } // TODO Set mime type //response.setContentType(JLWSConfig.MimeTypeMapping.getMimeTypeByExtension(fileExt)); response.flushHeaders(); response.serveStream(inputStream); } catch (IOException e) { throw new UnexpectedSituationException(e); } finally { IOUtilities.closeSilently(inputStream); } }
/** * Flushes the output. * * @throws IOException */ public void flush() throws IOException { // It makes no sense to set chunked encoding if there is no print writer if (printWriter != null && printWriter instanceof ChunkedPrintWriter) { getHeaders().setHeader(Headers.HEADER_TRANSFER_ENCODING, TRANSFER_ENCODING_CHUNKED); } if (!isCommitted()) { flushHeaders(); } if (printWriter != null) { printWriter.writeEnd(); printWriter.flush(); } outputStream.flush(); } }
/** * Terminates servlet. Sets all necessary headers, flushes content. * * @param request * @param response * @throws IOException */ private void terminate(final HttpServletRequestImpl request, final HttpServletResponseImpl response) throws IOException { freeUploadedUnprocessedFiles(request.getUploadedFiles()); HttpSessionImpl session = (HttpSessionImpl) request.getSession(false); if (session != null) { try { ((ServletContextImpl) request.getServletContext()).handleSession(session, response); } catch (IOException e) { LOGGER.log(Level.WARNING, "Unable to persist session", e); } } if (!response.isCommitted()) { if (response.getContentType() == null) { response.setContentType(DEFAULT_RESPONSE_CONTENT_TYPE); } response.getHeaders().setHeader(Headers.HEADER_CACHE_CONTROL, HEADER_VALUE_NO_CACHE); response.getHeaders().setHeader(Headers.HEADER_PRAGMA, HEADER_VALUE_NO_CACHE); } response.flush(); }
@Test public void shouldRedirectProperly() throws IOException { String url = "/SomeUrl"; httpServletResponseImpl.sendRedirect(url); assertThat(httpServletResponseImpl.getStatus(), is("HTTP/1.1 301 Moved Permanently")); assertThat(httpServletResponseImpl.getHeaders().getHeader(Headers.HEADER_LOCATION), is(url)); }
/** * Flushes headers, returns false when headers already flushed. * <p/> * Can be called once per response, after the first call "locks" itself. * * @return true if headers flushed * @throws IllegalStateException when headers have been previously flushed. * @throws IOException */ public void flushHeaders() throws IllegalStateException, IOException { if (isCommitted) { throw new IllegalStateException("Headers should not be committed more than once."); } isCommitted = true; for (Cookie cookie : cookies) { headers.setHeader(Headers.HEADER_SET_COOKIE, cookieHeaderSerializer.serialize(cookie)); } byte[] head = (getStatus() + NEW_LINE + headersSerializer.serialize(headers)) .getBytes(StandardCharsets.UTF_8); InputStream inputStream = new ByteArrayInputStream(head); serveStream(inputStream); IOUtilities.closeSilently(inputStream); }
@Test public void shouldSetHeadersProperly() { httpServletResponseImpl.setHeader("StringValue", "value"); httpServletResponseImpl.setIntHeader("IntValue", 1); assertThat(httpServletResponseImpl.getHeaders().getHeader("StringValue"), is("value")); assertThat(httpServletResponseImpl.getHeaders().getHeader("IntValue"), is("1")); } }
/** * Sets default response headers. * * @param request * @param response */ private void setDefaultResponseHeaders(final HttpServletRequest request, final HttpServletResponseImpl response) { boolean isKeepAlive = false; if (request.getHeader(Headers.HEADER_CONNECTION) != null) { isKeepAlive = request.getHeader(Headers.HEADER_CONNECTION).equalsIgnoreCase("keep-alive"); } response.setKeepAlive(isKeepAlive && serverConfig.isKeepAlive()); response.getHeaders().setHeader(Headers.HEADER_SERVER, WebServer.SIGNATURE); }
@Test(expected = IllegalStateException.class) public void shouldNotAllowHeadersToBeFlushedTwice() throws IOException { try { httpServletResponseImpl.flushHeaders(); } catch (IllegalStateException e) { fail("Should not throw exception on the first call"); } httpServletResponseImpl.flushHeaders(); }
/** * {@inheritDoc} */ @Override public void sendRedirect(final String location) { this.setStatus(HttpServletResponse.STATUS_MOVED_PERMANENTLY); headers.setHeader(Headers.HEADER_LOCATION, location); }
/** * Tells whether the transfer encoding is chunked. * * @return */ private boolean isTransferChunked() { if (!getHeaders().containsHeader(Headers.HEADER_TRANSFER_ENCODING) || getHeaders().containsHeader(Headers.HEADER_CONTENT_LENGTH)) { return false; } return getHeaders().getHeader(Headers.HEADER_TRANSFER_ENCODING).equalsIgnoreCase(TRANSFER_ENCODING_CHUNKED); }
@Test public void shouldServeBuiltinDocument() throws Exception { AbstractHtmlErrorHandler handler = new SampleHtmlErrorHanlder("500", "MSG_TOKEN", "EXPLANATION_TOKEN", null); handler.serve(response); assertThat(response.getStatus(), containsString("500")); assertThat(outputStream.toString(), containsString("MSG_TOKEN")); assertThat(outputStream.toString(), containsString("EXPLANATION_TOKEN")); }
/** * Handles session storage/invalidation, sets session cookies. * * @param session * @param response * @throws IOException */ public void handleSession(final HttpSessionImpl session, final HttpServletResponseImpl response) throws IOException { Cookie cookie = new Cookie(HttpSessionImpl.COOKIE_NAME, ""); if (session.isInvalidated()) { cookie.setMaxAge(MAX_AGE_IN_PAST); sessionStorage.removeSession(session); LOGGER.log(Level.FINE, "Invalidated session {0}", new Object[]{session.getId()}); } else { cookie.setValue(session.getId()); sessionStorage.persistSession(session); } response.addCookie(cookie); }
/** * {@inheritDoc} */ @Override public void load(final String path, final HttpServletRequestImpl request, final HttpServletResponseImpl response) throws IOException { ServletContextImpl servletContext = servletContextHelper.getResolvedContext(servletContexts, path); Objects.requireNonNull(servletContext); ServletMapping servletMapping = servletContextHelper.getResolvedServletMapping(servletContext, path); request.setServletContext(servletContext); Servlet servlet = getServlet(servletMapping, new ServletConfigImpl(servletContext)); response.setStatus(HttpServletResponse.STATUS_OK); try { FilterChainImpl filterChain = getFilterChain(path, servletContext, servlet); filterChain.doFilter(request, response); terminate(request, response); } catch (ServletException | FilterInitializationException e) { throw new UnexpectedSituationException(e); } }
response.setStatus(HttpServletResponse.STATUS_PARTIAL_CONTENT); response.getHeaders().setHeader(Headers.HEADER_CONTENT_RANGE, "bytes " + getRanges(ranges) + "/" + file.length()); response.setContentLength(rangeLength); response.setContentType(contentType); } else { boundary = StringUtilities.generateRandom(); response.setContentLength(rangePartHeaderSerializer.getPartHeadersLength(ranges, boundary, contentType, file.length()) + rangeLength); response.setContentType("multipart/byteranges; boundary=" + boundary); response.flushHeaders(); response.serveStream(fileInputStream, ranges.get(0)); } else { response.serveStream(fileInputStream, ranges, boundary, contentType, file.length()); response.flush();
@Test public void shouldFlushHeadersOnFirstUseForByteSection() throws IOException { OutputStream out = mock(OutputStream.class); byte[] data = "Hello World".getBytes(Charset.defaultCharset()); HttpServletResponseImpl response = mock(HttpServletResponseImpl.class); ServletOutputStreamImpl outW = new ServletOutputStreamImpl(out, response); try { when(response.isCommitted()).thenReturn(false); outW.write(data, 0, 1); when(response.isCommitted()).thenReturn(true); outW.write(data, 0, 1); verify(out, times(2)).write(data, 0, 1); verify(response, times(1)).flushHeaders(); } finally { outW.close(); } }