c) throws ServletException {
return null;
}
@Override
public void declareRoles(String... roleNames) {
}
@Override
public String getVirtualServerName() {
return null;
}
@Override
public ClassLoader getClassLoader() {
return classLoader;
}
@Override
public JspConfigDescriptor getJspConfigDescriptor() {
return null;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainer.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import com.google.common.base.StandardSystemProperty;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.EpollChannelOption;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.concurrent.DefaultEventExecutorGroup;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.boot.context.embedded.EmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerException;
import java.net.InetSocketAddress;
/**
* An {@link EmbeddedServletContainer} used to control an embedded Netty instance, that bridges to
* {@link javax.servlet.http.HttpServletRequest} and from {@link javax.servlet.http.HttpServletResponse}
* to Netty HTTP codec {@link io.netty.handler.codec.http.HttpMessage}s.
*
* This is a minimal Servlet 3.1 implementation to provide for the opinionated embedded servlet container model for
* Spring Boot, supporting a single context, runtime {@link javax.servlet.Registration} only, and no default or JSP
* servlets.
*
* This class should be created using the {@link NettyEmbeddedServletContainerFactory}.
*
* @author Danny Thomas
*/
public class NettyEmbeddedServletContainer implements EmbeddedServletContainer {
private final Log logger = LogFactory.getLog(getClass());
private final InetSocketAddress address;
private final NettyEmbeddedContext context;
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
private DefaultEventExecutorGroup servletExecutor;
public NettyEmbeddedServletContainer(InetSocketAddress address, NettyEmbeddedContext context) {
this.address = address;
this.context = context;
}
@Override
public void start() throws EmbeddedServletContainerException {
ServerBootstrap b = new ServerBootstrap();
groups(b);
servletExecutor = new DefaultEventExecutorGroup(50);
b.childHandler(new NettyEmbeddedServletInitializer(servletExecutor, context));
// Don't yet need the complexity of lifecycle state, listeners etc, so tell the context it's initialised here
context.setInitialised(true);
ChannelFuture future = b.bind(address).awaitUninterruptibly();
//noinspection ThrowableResultOfMethodCallIgnored
Throwable cause = future.cause();
if (null != cause) {
throw new EmbeddedServletContainerException("Could not start Netty server", cause);
}
logger.info(context.getServerInfo() + " started on port: " + getPort());
}
private void groups(ServerBootstrap b) {
if (StandardSystemProperty.OS_NAME.value().equals("Linux")) {
bossGroup = new EpollEventLoopGroup(1);
workerGroup = new EpollEventLoopGroup();
b.channel(EpollServerSocketChannel.class)
.group(bossGroup, workerGroup)
.option(EpollChannelOption.TCP_CORK, true);
} else {
bossGroup = new NioEventLoopGroup(1);
workerGroup = new NioEventLoopGroup();
b.channel(NioServerSocketChannel.class)
.group(bossGroup, workerGroup);
}
b.option(ChannelOption.TCP_NODELAY, true)
.option(ChannelOption.SO_REUSEADDR, true)
.option(ChannelOption.SO_BACKLOG, 100);
logger.info("Bootstrap configuration: " + b.toString());
}
@Override
public void stop() throws EmbeddedServletContainerException {
try {
if (null != bossGroup) {
bossGroup.shutdownGracefully().await();
}
if (null != workerGroup) {
workerGroup.shutdownGracefully().await();
}
if (null != servletExecutor) {
servletExecutor.shutdownGracefully().await();
}
} catch (InterruptedException e) {
throw new EmbeddedServletContainerException("Container stop interrupted", e);
}
}
@Override
public int getPort() {
return address.getPort();
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainerAutoConfiguration.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.bootstrap.Bootstrap;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.autoconfigure.condition.SearchStrategy;
import org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration.EmbeddedServletContainerCustomizerBeanPostProcessorRegistrar;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
/**
* {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration Auto-configuration} for an embedded servlet containers.
*
* @author Danny Thomas
*/
@Order(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(EmbeddedServletContainerCustomizerBeanPostProcessorRegistrar.class)
public class NettyEmbeddedServletContainerAutoConfiguration {
@Configuration
@ConditionalOnClass({Bootstrap.class})
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
public static class EmbeddedNetty {
@Bean
public NettyEmbeddedServletContainerFactory nettyEmbeddedServletContainerFactory() {
return new NettyEmbeddedServletContainerFactory();
}
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainerFactory.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.bootstrap.Bootstrap;
import org.springframework.boot.context.embedded.AbstractEmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.EmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.ServletContextInitializer;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.ClassUtils;
import javax.servlet.ServletException;
import java.net.InetSocketAddress;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Random;
/**
* An {@link EmbeddedServletContainerFactory} that can be used to create {@link NettyEmbeddedServletContainer}s.
*
* @author Danny Thomas
*/
public class NettyEmbeddedServletContainerFactory extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
public static final String SERVER_INFO = "netty/servlet";
private ResourceLoader resourceLoader;
@Override
public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
ClassLoader parentClassLoader = resourceLoader != null ? resourceLoader.getClassLoader() : ClassUtils.getDefaultClassLoader();
Package nettyPackage = Bootstrap.class.getPackage();
String title = nettyPackage.getImplementationTitle();
String version = nettyPackage.getImplementationVersion();
logger.info("Running with " + title + " " + version);
NettyEmbeddedContext context = new NettyEmbeddedContext(getContextPath(), new URLClassLoader(new URL[]{}, parentClassLoader), SERVER_INFO);
if (isRegisterDefaultServlet()) {
logger.warn("This container does not support a default servlet");
}
if (isRegisterJspServlet()) {
logger.warn("This container does not support a JSP servlet");
}
for (ServletContextInitializer initializer : initializers) {
try {
initializer.onStartup(context);
} catch (ServletException e) {
throw new RuntimeException(e);
}
}
int port = getPort() > 0 ? getPort() : new Random().nextInt(65535 - 1024) + 1024;
InetSocketAddress address = new InetSocketAddress(port);
logger.info("Server initialized with port: " + port);
return new NettyEmbeddedServletContainer(address, context);
}
@Override
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletInitializer.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.util.concurrent.EventExecutorGroup;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* {@link ChannelInitializer} for {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedServletContainer}.
*
* @author Danny Thomas
*/
class NettyEmbeddedServletInitializer extends ChannelInitializer {
private final EventExecutorGroup servletExecutor;
private final RequestDispatcherHandler requestDispatcherHandler;
private final NettyEmbeddedContext servletContext;
NettyEmbeddedServletInitializer(EventExecutorGroup servletExecutor, NettyEmbeddedContext servletContext) {
this.servletContext = servletContext;
this.servletExecutor = checkNotNull(servletExecutor);
requestDispatcherHandler = new RequestDispatcherHandler(servletContext);
}
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast("codec", new HttpServerCodec(4096, 8192, 8192, false));
p.addLast("servletInput", new ServletContentHandler(servletContext));
p.addLast(servletExecutor, "filterChain", requestDispatcherHandler);
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyFilterRegistration.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterRegistration;
import javax.servlet.ServletException;
import java.util.Collection;
import java.util.EnumSet;
/**
* A {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedContext} {@link javax.servlet.FilterRegistration}.
*
* @author Danny Thomas
*/
class NettyFilterRegistration extends AbstractNettyRegistration implements FilterRegistration.Dynamic {
private volatile boolean initialised;
private Filter filter;
NettyFilterRegistration(NettyEmbeddedContext context, String filterName, String className, Filter filter) {
super(filterName, className, context);
this.filter = filter;
}
public Filter getFilter() throws ServletException {
if (!initialised) {
synchronized (this) {
if (!initialised) {
if (null == filter) {
try {
filter = (Filter) Class.forName(getClassName()).newInstance();
} catch (Exception e) {
throw new ServletException(e);
}
}
filter.init(this);
initialised = true;
}
}
}
return filter;
}
@Override
public void addMappingForServletNames(EnumSet dispatcherTypes, boolean isMatchAfter, String... servletNames) {
}
@Override
public Collection getServletNameMappings() {
return null;
}
@Override
public void addMappingForUrlPatterns(EnumSet dispatcherTypes, boolean isMatchAfter, String... urlPatterns) {
NettyEmbeddedContext context = getNettyContext();
for (String urlPattern : urlPatterns) {
context.addFilterMapping(dispatcherTypes, isMatchAfter, urlPattern);
}
}
@Override
public Collection getUrlPatternMappings() {
return null;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyHttpServletRequest.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.HttpRequest;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.*;
/**
* {@link HttpServletRequest} wrapper for Netty's {@link HttpRequest}.
*
* @author Danny Thomas
*/
class NettyHttpServletRequest implements HttpServletRequest {
public static final String DISPATCHER_TYPE = NettyRequestDispatcher.class.getName() + ".DISPATCHER_TYPE";
private final ChannelHandlerContext ctx;
private final NettyEmbeddedContext servletContext;
private final HttpRequest request;
private final ServletInputStream inputStream;
private final Map attributes;
private boolean asyncSupported = true;
private NettyAsyncContext asyncContext;
private HttpServletResponse servletResponse;
NettyHttpServletRequest(ChannelHandlerContext ctx, NettyEmbeddedContext servletContext, HttpRequest request, HttpServletResponse servletResponse, ServletInputStream inputStream) {
this.ctx = ctx;
this.servletContext = servletContext;
this.request = request;
this.servletResponse = servletResponse;
this.inputStream = inputStream;
this.attributes = new HashMap<>();
}
HttpRequest getNettyRequest() {
return request;
}
@Override
public String getAuthType() {
return null;
}
@Override
public Cookie[] getCookies() {
return new Cookie[0];
}
@Override
public long getDateHeader(String name) {
return 0;
}
@Override
public String getHeader(String name) {
return null;
}
@Override
public Enumeration getHeaders(String name) {
return Collections.emptyEnumeration();
}
@Override
public Enumeration getHeaderNames() {
return Collections.emptyEnumeration();
}
@Override
public int getIntHeader(String name) {
return 0;
}
@Override
public String getMethod() {
return request.method().name();
}
@Override
public String getPathInfo() {
return null;
}
@Override
public String getPathTranslated() {
return null;
}
@Override
public String getContextPath() {
String requestURI = getRequestURI();
// FIXME implement properly
return "/".equals(requestURI) ? "" : requestURI;
}
@Override
public String getQueryString() {
return null;
}
@Override
public String getRemoteUser() {
return null;
}
@Override
public boolean isUserInRole(String role) {
return false;
}
@Override
public Principal getUserPrincipal() {
return null;
}
@Override
public String getRequestedSessionId() {
return null;
}
@Override
public String getRequestURI() {
return request.uri();
}
@Override
public StringBuffer getRequestURL() {
return null;
}
@Override
public String getServletPath() {
return getRequestURI();
}
@Override
public HttpSession getSession(boolean create) {
return null;
}
@Override
public HttpSession getSession() {
return null;
}
@Override
public String changeSessionId() {
return null;
}
@Override
public boolean isRequestedSessionIdValid() {
return false;
}
@Override
public boolean isRequestedSessionIdFromCookie() {
return false;
}
@Override
public boolean isRequestedSessionIdFromURL() {
return false;
}
@Override
public boolean isRequestedSessionIdFromUrl() {
return false;
}
@Override
public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
return false;
}
@Override
public void login(String username, String password) throws ServletException {
}
@Override
public void logout() throws ServletException {
}
@Override
public Collection getParts() throws IOException, IllegalStateException, ServletException {
return null;
}
@Override
public Part getPart(String name) throws IOException, IllegalStateException, ServletException {
return null;
}
@Override
public T upgrade(Class handlerClass) throws IOException, ServletException {
return null;
}
@Override
public Object getAttribute(String name) {
synchronized (attributes) {
return attributes.get(name);
}
}
@Override
public Enumeration getAttributeNames() {
synchronized (attributes) {
return Collections.enumeration(attributes.keySet());
}
}
@Override
public String getCharacterEncoding() {
return null;
}
@Override
public void setCharacterEncoding(String env) throws UnsupportedEncodingException {
}
@Override
public int getContentLength() {
return 0;
}
@Override
public long getContentLengthLong() {
return 0;
}
@Override
public String getContentType() {
return null;
}
@Override
public ServletInputStream getInputStream() throws IOException {
return inputStream;
}
@Override
public String getParameter(String name) {
return null;
}
@Override
public Enumeration getParameterNames() {
return null;
}
@Override
public String[] getParameterValues(String name) {
return new String[0];
}
@Override
public Map getParameterMap() {
return null;
}
@Override
public String getProtocol() {
return request.protocolVersion().protocolName();
}
@Override
public String getScheme() {
return null;
}
@Override
public String getServerName() {
return null;
}
@Override
public int getServerPort() {
return 0;
}
@Override
public BufferedReader getReader() throws IOException {
return null;
}
@Override
public String getRemoteAddr() {
return null;
}
@Override
public String getRemoteHost() {
return null;
}
@Override
public void setAttribute(String name, Object o) {
synchronized (attributes) {
attributes.put(name, o);
}
}
@Override
public void removeAttribute(String name) {
synchronized (attributes) {
attributes.remove(name);
}
}
@Override
public Locale getLocale() {
return null;
}
@Override
public Enumeration getLocales() {
return null;
}
@Override
public boolean isSecure() {
return false;
}
@Override
public RequestDispatcher getRequestDispatcher(String path) {
return null;
}
@Override
public String getRealPath(String path) {
return null;
}
@Override
public int getRemotePort() {
return 0;
}
@Override
public String getLocalName() {
return null;
}
@Override
public String getLocalAddr() {
return null;
}
@Override
public int getLocalPort() {
return 0;
}
@Override
public ServletContext getServletContext() {
return servletContext;
}
@Override
public AsyncContext startAsync() {
return startAsync(this, null);
}
@Override
public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) {
return ((NettyAsyncContext) getAsyncContext()).startAsync(servletRequest, servletResponse);
}
@Override
public boolean isAsyncStarted() {
return null != asyncContext && asyncContext.isAsyncStarted();
}
void setAsyncSupported(boolean asyncSupported) {
this.asyncSupported = asyncSupported;
}
@Override
public boolean isAsyncSupported() {
return asyncSupported;
}
@Override
public AsyncContext getAsyncContext() {
if (null == asyncContext) {
asyncContext = new NettyAsyncContext(this, ctx);
}
return asyncContext;
}
@Override
public DispatcherType getDispatcherType() {
return attributes.containsKey(DISPATCHER_TYPE) ? (DispatcherType) attributes.get(DISPATCHER_TYPE) : DispatcherType.REQUEST;
}
public ServletResponse getServletResponse() {
return servletResponse;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyHttpServletResponse.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.net.MediaType;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.util.concurrent.FastThreadLocal;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import static com.google.common.base.Preconditions.checkState;
/**
* {@link HttpServletResponse} wrapper for Netty's {@link HttpResponse}.
*
* @author Danny Thomas
*/
class NettyHttpServletResponse implements HttpServletResponse {
private static final FastThreadLocal FORMAT = new FastThreadLocal() {
@Override
protected DateFormat initialValue() {
return new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z");
}
};
private static final Locale DEFAULT_LOCALE = Locale.getDefault();
private static final String DEFAULT_CHARACTER_ENCODING = Charsets.ISO_8859_1.name();
private final NettyEmbeddedContext servletContext;
private HttpResponse response;
private HttpResponseOutputStream outputStream;
private boolean usingOutputStream;
private PrintWriter writer;
private boolean committed;
private List cookies;
private String contentType;
private String characterEncoding = DEFAULT_CHARACTER_ENCODING;
private Locale locale;
NettyHttpServletResponse(ChannelHandlerContext ctx, NettyEmbeddedContext servletContext, HttpResponse response) {
this.servletContext = servletContext;
this.response = response;
this.outputStream = new HttpResponseOutputStream(ctx, this);
cookies = new ArrayList<>();
}
/**
* Get a Netty {@link HttpResponse}, committing the {@link HttpServletResponse}.
*/
public HttpResponse getNettyResponse() {
if (committed) {
return response;
}
committed = true;
HttpHeaders headers = response.headers();
if (null != contentType) {
String value = null == characterEncoding ? contentType : contentType + "; charset=" + characterEncoding;
headers.set(HttpHeaders.Names.CONTENT_TYPE, value);
}
CharSequence date = getFormattedDate();
headers.set(HttpHeaders.Names.DATE, date);
headers.set(HttpHeaders.Names.SERVER, servletContext.getServerInfoAscii());
// TODO cookies
return response;
}
@VisibleForTesting
CharSequence getFormattedDate() {
return HttpHeaders.newEntity(FORMAT.get().format(new Date()));
}
@Override
public void addCookie(Cookie cookie) {
cookies.add(cookie);
}
@Override
public boolean containsHeader(String name) {
return response.headers().contains(name);
}
@Override
public String encodeURL(String url) {
return null;
}
@Override
public String encodeRedirectURL(String url) {
return null;
}
@Override
public String encodeUrl(String url) {
return null;
}
@Override
public String encodeRedirectUrl(String url) {
return null;
}
@Override
public void sendError(int sc, String msg) throws IOException {
checkNotCommitted();
response.setStatus(new HttpResponseStatus(sc, msg));
}
@Override
public void sendError(int sc) throws IOException {
checkNotCommitted();
response.setStatus(HttpResponseStatus.valueOf(sc));
}
@Override
public void sendRedirect(String location) throws IOException {
checkNotCommitted();
// TODO implement
}
@Override
public void setDateHeader(String name, long date) {
response.headers().set(name, date);
}
@Override
public void addDateHeader(String name, long date) {
response.headers().add(name, date);
}
@Override
public void setHeader(String name, String value) {
if (setHeaderField(name, value)) {
return;
}
response.headers().set(name, value);
}
private boolean setHeaderField(String name, String value) {
// Handle headers that shouldn't be set directly, and are instance fields
char c = name.charAt(0);
if ('C' == c || 'c' == c) {
if (HttpHeaders.Names.CONTENT_TYPE.equalsIgnoreCase(name)) {
setContentType(value);
return true;
}
// TODO Content-Language?
}
return false;
}
@Override
public void addHeader(String name, String value) {
if (setHeaderField(name, value)) {
return;
}
response.headers().add(name, value);
}
@Override
public void setIntHeader(String name, int value) {
response.headers().set(name, value);
}
@Override
public void addIntHeader(String name, int value) {
response.headers().add(name, value);
}
@Override
public void setStatus(int sc) {
response.setStatus(HttpResponseStatus.valueOf(sc));
}
@Override
public void setStatus(int sc, String sm) {
response.setStatus(new HttpResponseStatus(sc, sm));
}
@Override
public int getStatus() {
return response.status().code();
}
@Override
public String getHeader(String name) {
return response.headers().get(name);
}
@Override
public Collection getHeaders(String name) {
return response.headers().getAll(name);
}
@Override
public Collection getHeaderNames() {
return response.headers().names();
}
@Override
public String getCharacterEncoding() {
return characterEncoding;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
checkState(!hasWriter(), "getWriter has already been called for this response");
usingOutputStream = true;
return outputStream;
}
@Override
public PrintWriter getWriter() throws IOException {
checkState(!usingOutputStream, "getOutputStream has already been called for this response");
if (!hasWriter()) {
writer = new PrintWriter(outputStream);
}
return writer;
}
@Override
public void setCharacterEncoding(String charset) {
if (hasWriter()) {
return;
}
characterEncoding = charset;
}
@Override
public void setContentType(String type) {
if (isCommitted()) {
return;
}
if (hasWriter()) {
return;
}
if (null == type) {
contentType = null;
return;
}
MediaType mediaType = MediaType.parse(type);
Optional charset = mediaType.charset();
if (charset.isPresent()) {
setCharacterEncoding(charset.get().name());
}
contentType = mediaType.type() + '/' + mediaType.subtype();
}
private boolean hasWriter() {
return null != writer;
}
@Override
public void setContentLength(int len) {
HttpHeaders.setContentLength(response, len);
}
@Override
public void setContentLengthLong(long len) {
HttpHeaders.setContentLength(response, len);
}
@Override
public void setBufferSize(int size) {
checkNotCommitted();
outputStream.setBufferSize(size);
}
@Override
public int getBufferSize() {
return outputStream.getBufferSize();
}
@Override
public void flushBuffer() throws IOException {
checkNotCommitted();
outputStream.flush();
}
@Override
public void resetBuffer() {
checkNotCommitted();
outputStream.resetBuffer();
}
@Override
public boolean isCommitted() {
return committed;
}
void checkNotCommitted() {
checkState(!committed, "Cannot perform this operation after response has been committed");
}
@Override
public void reset() {
resetBuffer();
usingOutputStream = false;
writer = null;
}
@Override
public void setLocale(Locale loc) {
locale = loc;
}
@Override
public Locale getLocale() {
return null == locale ? DEFAULT_LOCALE : locale;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyRequestDispatcher.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import javax.servlet.*;
import java.io.IOException;
/**
* @author Danny Thomas
*/
class NettyRequestDispatcher implements RequestDispatcher {
private final ServletContext context;
private final FilterChain filterChain;
NettyRequestDispatcher(ServletContext context, FilterChain filterChain) {
this.context = context;
this.filterChain = filterChain;
}
@Override
public void forward(ServletRequest request, ServletResponse response) throws ServletException, IOException {
request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.FORWARD);
// TODO implement
}
@Override
public void include(ServletRequest request, ServletResponse response) throws ServletException, IOException {
request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.INCLUDE);
// TODO implement
}
void dispatch(ServletRequest request, ServletResponse response) throws ServletException, IOException {
request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.ASYNC);
filterChain.doFilter(request, response);
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/NettyServletRegistration.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import javax.servlet.*;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
/**
* A {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedContext} {@link javax.servlet.ServletRegistration}.
*
* @author Danny Thomas
*/
class NettyServletRegistration extends AbstractNettyRegistration implements ServletRegistration.Dynamic {
private volatile boolean initialised;
private Servlet servlet;
NettyServletRegistration(NettyEmbeddedContext context, String servletName, String className, Servlet servlet) {
super(servletName, className, context);
this.servlet = servlet;
}
public Servlet getServlet() throws ServletException {
if (!initialised) {
synchronized (this) {
if (!initialised) {
if (null == servlet) {
try {
servlet = (Servlet) Class.forName(getClassName()).newInstance();
} catch (Exception e) {
throw new ServletException(e);
}
}
servlet.init(this);
initialised = true;
}
}
}
return servlet;
}
@Override
public void setLoadOnStartup(int loadOnStartup) {
}
@Override
public Set setServletSecurity(ServletSecurityElement constraint) {
return null;
}
@Override
public void setMultipartConfig(MultipartConfigElement multipartConfig) {
}
@Override
public void setRunAsRole(String roleName) {
}
@Override
public Set addMapping(String... urlPatterns) {
// TODO check for conflicts
NettyEmbeddedContext context = getNettyContext();
for (String urlPattern : urlPatterns) {
context.addServletMapping(urlPattern, getName());
}
return Collections.emptySet();
}
@Override
public Collection getMappings() {
return null;
}
@Override
public String getRunAsRole() {
return null;
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/RequestDispatcherHandler.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A {@link io.netty.channel.ChannelInboundHandler} that bridges to and from {@link HttpServletRequest}s and
* {@link HttpServletResponse}s from Netty HTTP codec objects.
*
* @author Danny Thomas
*/
@ChannelHandler.Sharable
class RequestDispatcherHandler extends SimpleChannelInboundHandler {
private final Log logger = LogFactory.getLog(getClass());
private final NettyEmbeddedContext context;
RequestDispatcherHandler(NettyEmbeddedContext context) {
this.context = checkNotNull(context);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, NettyHttpServletRequest request) throws Exception {
HttpServletResponse servletResponse = (HttpServletResponse) request.getServletResponse();
try {
NettyRequestDispatcher dispatcher = (NettyRequestDispatcher) context.getRequestDispatcher(request.getRequestURI());
if (dispatcher == null) {
servletResponse.sendError(404);
return;
}
dispatcher.dispatch(request, servletResponse);
} finally {
if (!request.isAsyncStarted()) {
servletResponse.getOutputStream().close();
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
logger.error("Unexpected exception caught during request", cause);
ctx.close();
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/ServletContentHandler.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.*;
/**
* {@link io.netty.channel.ChannelInboundHandler} responsible for initial request handling, and getting received
* {@link HttpContent} messages to the {@link HttpContentInputStream} for the request.
*/
class ServletContentHandler extends ChannelInboundHandlerAdapter {
private final NettyEmbeddedContext servletContext;
private HttpContentInputStream inputStream; // FIXME this feels wonky, need a better approach
ServletContentHandler(NettyEmbeddedContext servletContext) {
this.servletContext = servletContext;
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
inputStream = new HttpContentInputStream(ctx.channel());
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpRequest) {
HttpRequest request = (HttpRequest) msg;
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, false);
HttpHeaders.setKeepAlive(response, HttpHeaders.isKeepAlive(request));
NettyHttpServletResponse servletResponse = new NettyHttpServletResponse(ctx, servletContext, response);
NettyHttpServletRequest servletRequest = new NettyHttpServletRequest(ctx, servletContext, request, servletResponse, inputStream);
if (HttpHeaders.is100ContinueExpected(request)) {
ctx.write(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE), ctx.voidPromise());
}
ctx.fireChannelRead(servletRequest);
}
if (msg instanceof HttpContent) {
inputStream.addContent((HttpContent) msg);
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
inputStream.close();
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/SimpleFilterChain.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty;
import javax.servlet.*;
import java.io.IOException;
import java.util.Iterator;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A very simple {@link FilterChain} implementation.
*
* @author Danny Thomas
*/
class SimpleFilterChain implements FilterChain {
private final Iterator filterIterator;
private final Servlet servlet;
SimpleFilterChain(Servlet servlet, Iterable filters) throws ServletException {
this.filterIterator = checkNotNull(filters).iterator();
this.servlet = checkNotNull(servlet);
}
@Override
public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
if (filterIterator.hasNext()) {
Filter filter = filterIterator.next();
filter.doFilter(request, response, this);
} else {
servlet.service(request, response);
}
}
}
================================================
FILE: src/main/java/org/springframework/boot/context/embedded/netty/package-info.java
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
* Comment here.
*/
package org.springframework.boot.context.embedded.netty;
================================================
FILE: src/test/groovy/org/springframework/boot/context/embedded/netty/HttpContentInputStreamTest.groovy
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty
import com.google.common.base.Charsets
import io.netty.buffer.Unpooled
import io.netty.channel.Channel
import io.netty.handler.codec.http.DefaultHttpContent
import io.netty.handler.codec.http.LastHttpContent
import spock.lang.Specification
/**
* Tests for {@link HttpContentInputStream}.
*/
class HttpContentInputStreamTest extends Specification {
def channel
def stream
def setup() {
channel = Mock(Channel)
stream = new HttpContentInputStream(channel)
}
def 'a read with a an empty last content returns -1'() {
given:
stream.addContent(LastHttpContent.EMPTY_LAST_CONTENT)
expect:
stream.read() == -1
}
def 'a read with an empty last content, for a non-active channel, returns -1'() {
given:
stream.addContent(LastHttpContent.EMPTY_LAST_CONTENT)
expect:
stream.read() == -1
}
def 'an attempt to read with a non-active channel, throws IOException'() {
given:
channel.isActive() >> false
when:
stream.read()
then:
thrown(IOException)
}
def 'expected number of bytes and content is read for a single content read'() {
when:
stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer("My hovercraft is full of eels.", Charsets.UTF_8)))
then:
def b = new byte[30]
stream.read(b, 0, 30) == 30
new String(b) == "My hovercraft is full of eels."
}
def 'the expected number of bytes and content is read for partial read of two component contents'() {
when:
stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer("My hovercraft is full of eels.", Charsets.UTF_8)))
stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer(" I will not buy this record, it is scratched.", Charsets.UTF_8)))
then:
def b = new byte[75]
stream.read(b, 0, 30) == 30
stream.read(b, 30, 45) == 45
new String(b) == "My hovercraft is full of eels. I will not buy this record, it is scratched."
}
def 'zero length read returns 0'() {
expect:
stream.read(new byte[0], 0, 0) == 0
}
def 'stream is not finished'() {
expect:
!stream.isFinished()
}
def 'stream is not ready'() {
expect:
!stream.isReady()
}
def 'stream has no available bytes'() {
expect:
stream.available() == 0
}
}
================================================
FILE: src/test/groovy/org/springframework/boot/context/embedded/netty/PackageSanityTest.groovy
================================================
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.boot.context.embedded.netty
import com.google.common.base.Predicate
import com.google.common.testing.AbstractPackageSanityTests
import io.netty.buffer.ByteBuf
import io.netty.buffer.Unpooled
import org.junit.Ignore
import javax.annotation.Nullable
/**
* Sanity tests for {@link org.springframework.boot.context.embedded.netty}.
*/
@Ignore
// FIXME I've added a bunch of new classes that can't be instantiated automatically, that'll I'll need to add back here
class PackageSanityTest extends AbstractPackageSanityTests {
PackageSanityTest() {
setDefault(ByteBuf, Unpooled.buffer())
setDefault(NettyEmbeddedContext, new NettyEmbeddedContext("/", Thread.currentThread().getContextClassLoader(), "ServerInfo"))
ignoreClasses(new Predicate>() {
@Override
boolean apply(@Nullable Class input) {
input == AbstractNettyRegistration
}
})
}
}