c) throws ServletException {
352 | return null;
353 | }
354 |
355 | @Override
356 | public void declareRoles(String... roleNames) {
357 |
358 | }
359 |
360 | @Override
361 | public String getVirtualServerName() {
362 | return null;
363 | }
364 |
365 | @Override
366 | public ClassLoader getClassLoader() {
367 | return classLoader;
368 | }
369 |
370 | @Override
371 | public JspConfigDescriptor getJspConfigDescriptor() {
372 | return null;
373 | }
374 | }
375 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import com.google.common.base.StandardSystemProperty;
21 | import io.netty.bootstrap.ServerBootstrap;
22 | import io.netty.channel.ChannelFuture;
23 | import io.netty.channel.ChannelOption;
24 | import io.netty.channel.EventLoopGroup;
25 | import io.netty.channel.epoll.EpollChannelOption;
26 | import io.netty.channel.epoll.EpollEventLoopGroup;
27 | import io.netty.channel.epoll.EpollServerSocketChannel;
28 | import io.netty.channel.nio.NioEventLoopGroup;
29 | import io.netty.channel.socket.nio.NioServerSocketChannel;
30 | import io.netty.util.concurrent.DefaultEventExecutorGroup;
31 | import org.apache.commons.logging.Log;
32 | import org.apache.commons.logging.LogFactory;
33 | import org.springframework.boot.context.embedded.EmbeddedServletContainer;
34 | import org.springframework.boot.context.embedded.EmbeddedServletContainerException;
35 |
36 | import java.net.InetSocketAddress;
37 |
38 | /**
39 | * An {@link EmbeddedServletContainer} used to control an embedded Netty instance, that bridges to
40 | * {@link javax.servlet.http.HttpServletRequest} and from {@link javax.servlet.http.HttpServletResponse}
41 | * to Netty HTTP codec {@link io.netty.handler.codec.http.HttpMessage}s.
42 | *
43 | * This is a minimal Servlet 3.1 implementation to provide for the opinionated embedded servlet container model for
44 | * Spring Boot, supporting a single context, runtime {@link javax.servlet.Registration} only, and no default or JSP
45 | * servlets.
46 | *
47 | * This class should be created using the {@link NettyEmbeddedServletContainerFactory}.
48 | *
49 | * @author Danny Thomas
50 | */
51 | public class NettyEmbeddedServletContainer implements EmbeddedServletContainer {
52 | private final Log logger = LogFactory.getLog(getClass());
53 | private final InetSocketAddress address;
54 | private final NettyEmbeddedContext context;
55 |
56 | private EventLoopGroup bossGroup;
57 | private EventLoopGroup workerGroup;
58 | private DefaultEventExecutorGroup servletExecutor;
59 |
60 | public NettyEmbeddedServletContainer(InetSocketAddress address, NettyEmbeddedContext context) {
61 | this.address = address;
62 | this.context = context;
63 | }
64 |
65 | @Override
66 | public void start() throws EmbeddedServletContainerException {
67 | ServerBootstrap b = new ServerBootstrap();
68 | groups(b);
69 | servletExecutor = new DefaultEventExecutorGroup(50);
70 | b.childHandler(new NettyEmbeddedServletInitializer(servletExecutor, context));
71 |
72 | // Don't yet need the complexity of lifecycle state, listeners etc, so tell the context it's initialised here
73 | context.setInitialised(true);
74 |
75 | ChannelFuture future = b.bind(address).awaitUninterruptibly();
76 | //noinspection ThrowableResultOfMethodCallIgnored
77 | Throwable cause = future.cause();
78 | if (null != cause) {
79 | throw new EmbeddedServletContainerException("Could not start Netty server", cause);
80 | }
81 | logger.info(context.getServerInfo() + " started on port: " + getPort());
82 | }
83 |
84 | private void groups(ServerBootstrap b) {
85 | if (StandardSystemProperty.OS_NAME.value().equals("Linux")) {
86 | bossGroup = new EpollEventLoopGroup(1);
87 | workerGroup = new EpollEventLoopGroup();
88 | b.channel(EpollServerSocketChannel.class)
89 | .group(bossGroup, workerGroup)
90 | .option(EpollChannelOption.TCP_CORK, true);
91 | } else {
92 | bossGroup = new NioEventLoopGroup(1);
93 | workerGroup = new NioEventLoopGroup();
94 | b.channel(NioServerSocketChannel.class)
95 | .group(bossGroup, workerGroup);
96 | }
97 | b.option(ChannelOption.TCP_NODELAY, true)
98 | .option(ChannelOption.SO_REUSEADDR, true)
99 | .option(ChannelOption.SO_BACKLOG, 100);
100 | logger.info("Bootstrap configuration: " + b.toString());
101 | }
102 |
103 | @Override
104 | public void stop() throws EmbeddedServletContainerException {
105 | try {
106 | if (null != bossGroup) {
107 | bossGroup.shutdownGracefully().await();
108 | }
109 | if (null != workerGroup) {
110 | workerGroup.shutdownGracefully().await();
111 | }
112 | if (null != servletExecutor) {
113 | servletExecutor.shutdownGracefully().await();
114 | }
115 | } catch (InterruptedException e) {
116 | throw new EmbeddedServletContainerException("Container stop interrupted", e);
117 | }
118 | }
119 |
120 | @Override
121 | public int getPort() {
122 | return address.getPort();
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainerAutoConfiguration.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.bootstrap.Bootstrap;
21 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
22 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
23 | import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
24 | import org.springframework.boot.autoconfigure.condition.SearchStrategy;
25 | import org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration.EmbeddedServletContainerCustomizerBeanPostProcessorRegistrar;
26 | import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
27 | import org.springframework.context.annotation.Bean;
28 | import org.springframework.context.annotation.Configuration;
29 | import org.springframework.context.annotation.Import;
30 | import org.springframework.core.Ordered;
31 | import org.springframework.core.annotation.Order;
32 |
33 | /**
34 | * {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration Auto-configuration} for an embedded servlet containers.
35 | *
36 | * @author Danny Thomas
37 | */
38 | @Order(Ordered.HIGHEST_PRECEDENCE)
39 | @Configuration
40 | @ConditionalOnWebApplication
41 | @Import(EmbeddedServletContainerCustomizerBeanPostProcessorRegistrar.class)
42 | public class NettyEmbeddedServletContainerAutoConfiguration {
43 | @Configuration
44 | @ConditionalOnClass({Bootstrap.class})
45 | @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
46 | public static class EmbeddedNetty {
47 | @Bean
48 | public NettyEmbeddedServletContainerFactory nettyEmbeddedServletContainerFactory() {
49 | return new NettyEmbeddedServletContainerFactory();
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletContainerFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.bootstrap.Bootstrap;
21 | import org.springframework.boot.context.embedded.AbstractEmbeddedServletContainerFactory;
22 | import org.springframework.boot.context.embedded.EmbeddedServletContainer;
23 | import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
24 | import org.springframework.boot.context.embedded.ServletContextInitializer;
25 | import org.springframework.context.ResourceLoaderAware;
26 | import org.springframework.core.io.ResourceLoader;
27 | import org.springframework.util.ClassUtils;
28 |
29 | import javax.servlet.ServletException;
30 | import java.net.InetSocketAddress;
31 | import java.net.URL;
32 | import java.net.URLClassLoader;
33 | import java.util.Random;
34 |
35 | /**
36 | * An {@link EmbeddedServletContainerFactory} that can be used to create {@link NettyEmbeddedServletContainer}s.
37 | *
38 | * @author Danny Thomas
39 | */
40 | public class NettyEmbeddedServletContainerFactory extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
41 | public static final String SERVER_INFO = "netty/servlet";
42 | private ResourceLoader resourceLoader;
43 |
44 | @Override
45 | public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
46 | ClassLoader parentClassLoader = resourceLoader != null ? resourceLoader.getClassLoader() : ClassUtils.getDefaultClassLoader();
47 | Package nettyPackage = Bootstrap.class.getPackage();
48 | String title = nettyPackage.getImplementationTitle();
49 | String version = nettyPackage.getImplementationVersion();
50 | logger.info("Running with " + title + " " + version);
51 | NettyEmbeddedContext context = new NettyEmbeddedContext(getContextPath(), new URLClassLoader(new URL[]{}, parentClassLoader), SERVER_INFO);
52 | if (isRegisterDefaultServlet()) {
53 | logger.warn("This container does not support a default servlet");
54 | }
55 | if (isRegisterJspServlet()) {
56 | logger.warn("This container does not support a JSP servlet");
57 | }
58 | for (ServletContextInitializer initializer : initializers) {
59 | try {
60 | initializer.onStartup(context);
61 | } catch (ServletException e) {
62 | throw new RuntimeException(e);
63 | }
64 | }
65 | int port = getPort() > 0 ? getPort() : new Random().nextInt(65535 - 1024) + 1024;
66 | InetSocketAddress address = new InetSocketAddress(port);
67 | logger.info("Server initialized with port: " + port);
68 | return new NettyEmbeddedServletContainer(address, context);
69 | }
70 |
71 | @Override
72 | public void setResourceLoader(ResourceLoader resourceLoader) {
73 | this.resourceLoader = resourceLoader;
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyEmbeddedServletInitializer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.channel.ChannelInitializer;
21 | import io.netty.channel.ChannelPipeline;
22 | import io.netty.channel.socket.SocketChannel;
23 | import io.netty.handler.codec.http.HttpServerCodec;
24 | import io.netty.util.concurrent.EventExecutorGroup;
25 |
26 | import static com.google.common.base.Preconditions.checkNotNull;
27 |
28 | /**
29 | * {@link ChannelInitializer} for {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedServletContainer}.
30 | *
31 | * @author Danny Thomas
32 | */
33 | class NettyEmbeddedServletInitializer extends ChannelInitializer {
34 | private final EventExecutorGroup servletExecutor;
35 | private final RequestDispatcherHandler requestDispatcherHandler;
36 | private final NettyEmbeddedContext servletContext;
37 |
38 | NettyEmbeddedServletInitializer(EventExecutorGroup servletExecutor, NettyEmbeddedContext servletContext) {
39 | this.servletContext = servletContext;
40 | this.servletExecutor = checkNotNull(servletExecutor);
41 | requestDispatcherHandler = new RequestDispatcherHandler(servletContext);
42 | }
43 |
44 | @Override
45 | protected void initChannel(SocketChannel ch) throws Exception {
46 | ChannelPipeline p = ch.pipeline();
47 | p.addLast("codec", new HttpServerCodec(4096, 8192, 8192, false));
48 | p.addLast("servletInput", new ServletContentHandler(servletContext));
49 | p.addLast(servletExecutor, "filterChain", requestDispatcherHandler);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyFilterRegistration.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import javax.servlet.DispatcherType;
21 | import javax.servlet.Filter;
22 | import javax.servlet.FilterRegistration;
23 | import javax.servlet.ServletException;
24 | import java.util.Collection;
25 | import java.util.EnumSet;
26 |
27 | /**
28 | * A {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedContext} {@link javax.servlet.FilterRegistration}.
29 | *
30 | * @author Danny Thomas
31 | */
32 | class NettyFilterRegistration extends AbstractNettyRegistration implements FilterRegistration.Dynamic {
33 | private volatile boolean initialised;
34 | private Filter filter;
35 |
36 | NettyFilterRegistration(NettyEmbeddedContext context, String filterName, String className, Filter filter) {
37 | super(filterName, className, context);
38 | this.filter = filter;
39 | }
40 |
41 | public Filter getFilter() throws ServletException {
42 | if (!initialised) {
43 | synchronized (this) {
44 | if (!initialised) {
45 | if (null == filter) {
46 | try {
47 | filter = (Filter) Class.forName(getClassName()).newInstance();
48 | } catch (Exception e) {
49 | throw new ServletException(e);
50 | }
51 | }
52 | filter.init(this);
53 | initialised = true;
54 | }
55 | }
56 | }
57 | return filter;
58 | }
59 |
60 | @Override
61 | public void addMappingForServletNames(EnumSet dispatcherTypes, boolean isMatchAfter, String... servletNames) {
62 |
63 | }
64 |
65 | @Override
66 | public Collection getServletNameMappings() {
67 | return null;
68 | }
69 |
70 | @Override
71 | public void addMappingForUrlPatterns(EnumSet dispatcherTypes, boolean isMatchAfter, String... urlPatterns) {
72 | NettyEmbeddedContext context = getNettyContext();
73 | for (String urlPattern : urlPatterns) {
74 | context.addFilterMapping(dispatcherTypes, isMatchAfter, urlPattern);
75 | }
76 | }
77 |
78 | @Override
79 | public Collection getUrlPatternMappings() {
80 | return null;
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyHttpServletRequest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.channel.ChannelHandlerContext;
21 | import io.netty.handler.codec.http.HttpRequest;
22 |
23 | import javax.servlet.*;
24 | import javax.servlet.http.*;
25 | import java.io.BufferedReader;
26 | import java.io.IOException;
27 | import java.io.UnsupportedEncodingException;
28 | import java.security.Principal;
29 | import java.util.*;
30 |
31 | /**
32 | * {@link HttpServletRequest} wrapper for Netty's {@link HttpRequest}.
33 | *
34 | * @author Danny Thomas
35 | */
36 | class NettyHttpServletRequest implements HttpServletRequest {
37 | public static final String DISPATCHER_TYPE = NettyRequestDispatcher.class.getName() + ".DISPATCHER_TYPE";
38 |
39 | private final ChannelHandlerContext ctx;
40 | private final NettyEmbeddedContext servletContext;
41 | private final HttpRequest request;
42 | private final ServletInputStream inputStream;
43 | private final Map attributes;
44 |
45 | private boolean asyncSupported = true;
46 | private NettyAsyncContext asyncContext;
47 | private HttpServletResponse servletResponse;
48 |
49 | NettyHttpServletRequest(ChannelHandlerContext ctx, NettyEmbeddedContext servletContext, HttpRequest request, HttpServletResponse servletResponse, ServletInputStream inputStream) {
50 | this.ctx = ctx;
51 | this.servletContext = servletContext;
52 | this.request = request;
53 | this.servletResponse = servletResponse;
54 | this.inputStream = inputStream;
55 | this.attributes = new HashMap<>();
56 | }
57 |
58 | HttpRequest getNettyRequest() {
59 | return request;
60 | }
61 |
62 | @Override
63 | public String getAuthType() {
64 | return null;
65 | }
66 |
67 | @Override
68 | public Cookie[] getCookies() {
69 | return new Cookie[0];
70 | }
71 |
72 | @Override
73 | public long getDateHeader(String name) {
74 | return 0;
75 | }
76 |
77 | @Override
78 | public String getHeader(String name) {
79 | return null;
80 | }
81 |
82 | @Override
83 | public Enumeration getHeaders(String name) {
84 | return Collections.emptyEnumeration();
85 | }
86 |
87 | @Override
88 | public Enumeration getHeaderNames() {
89 | return Collections.emptyEnumeration();
90 | }
91 |
92 | @Override
93 | public int getIntHeader(String name) {
94 | return 0;
95 | }
96 |
97 | @Override
98 | public String getMethod() {
99 | return request.method().name();
100 | }
101 |
102 | @Override
103 | public String getPathInfo() {
104 | return null;
105 | }
106 |
107 | @Override
108 | public String getPathTranslated() {
109 | return null;
110 | }
111 |
112 | @Override
113 | public String getContextPath() {
114 | String requestURI = getRequestURI();
115 | // FIXME implement properly
116 | return "/".equals(requestURI) ? "" : requestURI;
117 | }
118 |
119 | @Override
120 | public String getQueryString() {
121 | return null;
122 | }
123 |
124 | @Override
125 | public String getRemoteUser() {
126 | return null;
127 | }
128 |
129 | @Override
130 | public boolean isUserInRole(String role) {
131 | return false;
132 | }
133 |
134 | @Override
135 | public Principal getUserPrincipal() {
136 | return null;
137 | }
138 |
139 | @Override
140 | public String getRequestedSessionId() {
141 | return null;
142 | }
143 |
144 | @Override
145 | public String getRequestURI() {
146 | return request.uri();
147 | }
148 |
149 | @Override
150 | public StringBuffer getRequestURL() {
151 | return null;
152 | }
153 |
154 | @Override
155 | public String getServletPath() {
156 | return getRequestURI();
157 | }
158 |
159 | @Override
160 | public HttpSession getSession(boolean create) {
161 | return null;
162 | }
163 |
164 | @Override
165 | public HttpSession getSession() {
166 | return null;
167 | }
168 |
169 | @Override
170 | public String changeSessionId() {
171 | return null;
172 | }
173 |
174 | @Override
175 | public boolean isRequestedSessionIdValid() {
176 | return false;
177 | }
178 |
179 | @Override
180 | public boolean isRequestedSessionIdFromCookie() {
181 | return false;
182 | }
183 |
184 | @Override
185 | public boolean isRequestedSessionIdFromURL() {
186 | return false;
187 | }
188 |
189 | @Override
190 | public boolean isRequestedSessionIdFromUrl() {
191 | return false;
192 | }
193 |
194 | @Override
195 | public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
196 | return false;
197 | }
198 |
199 | @Override
200 | public void login(String username, String password) throws ServletException {
201 |
202 | }
203 |
204 | @Override
205 | public void logout() throws ServletException {
206 |
207 | }
208 |
209 | @Override
210 | public Collection getParts() throws IOException, IllegalStateException, ServletException {
211 | return null;
212 | }
213 |
214 | @Override
215 | public Part getPart(String name) throws IOException, IllegalStateException, ServletException {
216 | return null;
217 | }
218 |
219 | @Override
220 | public T upgrade(Class handlerClass) throws IOException, ServletException {
221 | return null;
222 | }
223 |
224 | @Override
225 | public Object getAttribute(String name) {
226 | synchronized (attributes) {
227 | return attributes.get(name);
228 | }
229 | }
230 |
231 | @Override
232 | public Enumeration getAttributeNames() {
233 | synchronized (attributes) {
234 | return Collections.enumeration(attributes.keySet());
235 | }
236 | }
237 |
238 | @Override
239 | public String getCharacterEncoding() {
240 | return null;
241 | }
242 |
243 | @Override
244 | public void setCharacterEncoding(String env) throws UnsupportedEncodingException {
245 |
246 | }
247 |
248 | @Override
249 | public int getContentLength() {
250 | return 0;
251 | }
252 |
253 | @Override
254 | public long getContentLengthLong() {
255 | return 0;
256 | }
257 |
258 | @Override
259 | public String getContentType() {
260 | return null;
261 | }
262 |
263 | @Override
264 | public ServletInputStream getInputStream() throws IOException {
265 | return inputStream;
266 | }
267 |
268 | @Override
269 | public String getParameter(String name) {
270 | return null;
271 | }
272 |
273 | @Override
274 | public Enumeration getParameterNames() {
275 | return null;
276 | }
277 |
278 | @Override
279 | public String[] getParameterValues(String name) {
280 | return new String[0];
281 | }
282 |
283 | @Override
284 | public Map getParameterMap() {
285 | return null;
286 | }
287 |
288 | @Override
289 | public String getProtocol() {
290 | return request.protocolVersion().protocolName();
291 | }
292 |
293 | @Override
294 | public String getScheme() {
295 | return null;
296 | }
297 |
298 | @Override
299 | public String getServerName() {
300 | return null;
301 | }
302 |
303 | @Override
304 | public int getServerPort() {
305 | return 0;
306 | }
307 |
308 | @Override
309 | public BufferedReader getReader() throws IOException {
310 | return null;
311 | }
312 |
313 | @Override
314 | public String getRemoteAddr() {
315 | return null;
316 | }
317 |
318 | @Override
319 | public String getRemoteHost() {
320 | return null;
321 | }
322 |
323 | @Override
324 | public void setAttribute(String name, Object o) {
325 | synchronized (attributes) {
326 | attributes.put(name, o);
327 | }
328 | }
329 |
330 | @Override
331 | public void removeAttribute(String name) {
332 | synchronized (attributes) {
333 | attributes.remove(name);
334 | }
335 | }
336 |
337 | @Override
338 | public Locale getLocale() {
339 | return null;
340 | }
341 |
342 | @Override
343 | public Enumeration getLocales() {
344 | return null;
345 | }
346 |
347 | @Override
348 | public boolean isSecure() {
349 | return false;
350 | }
351 |
352 | @Override
353 | public RequestDispatcher getRequestDispatcher(String path) {
354 | return null;
355 | }
356 |
357 | @Override
358 | public String getRealPath(String path) {
359 | return null;
360 | }
361 |
362 | @Override
363 | public int getRemotePort() {
364 | return 0;
365 | }
366 |
367 | @Override
368 | public String getLocalName() {
369 | return null;
370 | }
371 |
372 | @Override
373 | public String getLocalAddr() {
374 | return null;
375 | }
376 |
377 | @Override
378 | public int getLocalPort() {
379 | return 0;
380 | }
381 |
382 | @Override
383 | public ServletContext getServletContext() {
384 | return servletContext;
385 | }
386 |
387 | @Override
388 | public AsyncContext startAsync() {
389 | return startAsync(this, null);
390 | }
391 |
392 | @Override
393 | public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) {
394 | return ((NettyAsyncContext) getAsyncContext()).startAsync(servletRequest, servletResponse);
395 | }
396 |
397 | @Override
398 | public boolean isAsyncStarted() {
399 | return null != asyncContext && asyncContext.isAsyncStarted();
400 | }
401 |
402 | void setAsyncSupported(boolean asyncSupported) {
403 | this.asyncSupported = asyncSupported;
404 | }
405 |
406 | @Override
407 | public boolean isAsyncSupported() {
408 | return asyncSupported;
409 | }
410 |
411 | @Override
412 | public AsyncContext getAsyncContext() {
413 | if (null == asyncContext) {
414 | asyncContext = new NettyAsyncContext(this, ctx);
415 | }
416 | return asyncContext;
417 | }
418 |
419 | @Override
420 | public DispatcherType getDispatcherType() {
421 | return attributes.containsKey(DISPATCHER_TYPE) ? (DispatcherType) attributes.get(DISPATCHER_TYPE) : DispatcherType.REQUEST;
422 | }
423 |
424 | public ServletResponse getServletResponse() {
425 | return servletResponse;
426 | }
427 | }
428 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyHttpServletResponse.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import com.google.common.annotations.VisibleForTesting;
21 | import com.google.common.base.Charsets;
22 | import com.google.common.base.Optional;
23 | import com.google.common.net.MediaType;
24 | import io.netty.channel.ChannelHandlerContext;
25 | import io.netty.handler.codec.http.HttpHeaders;
26 | import io.netty.handler.codec.http.HttpResponse;
27 | import io.netty.handler.codec.http.HttpResponseStatus;
28 | import io.netty.util.concurrent.FastThreadLocal;
29 |
30 | import javax.servlet.ServletOutputStream;
31 | import javax.servlet.http.Cookie;
32 | import javax.servlet.http.HttpServletResponse;
33 | import java.io.IOException;
34 | import java.io.PrintWriter;
35 | import java.nio.charset.Charset;
36 | import java.text.DateFormat;
37 | import java.text.SimpleDateFormat;
38 | import java.util.*;
39 |
40 | import static com.google.common.base.Preconditions.checkState;
41 |
42 | /**
43 | * {@link HttpServletResponse} wrapper for Netty's {@link HttpResponse}.
44 | *
45 | * @author Danny Thomas
46 | */
47 | class NettyHttpServletResponse implements HttpServletResponse {
48 | private static final FastThreadLocal FORMAT = new FastThreadLocal() {
49 | @Override
50 | protected DateFormat initialValue() {
51 | return new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z");
52 | }
53 | };
54 |
55 | private static final Locale DEFAULT_LOCALE = Locale.getDefault();
56 | private static final String DEFAULT_CHARACTER_ENCODING = Charsets.ISO_8859_1.name();
57 |
58 | private final NettyEmbeddedContext servletContext;
59 | private HttpResponse response;
60 | private HttpResponseOutputStream outputStream;
61 | private boolean usingOutputStream;
62 | private PrintWriter writer;
63 | private boolean committed;
64 | private List cookies;
65 | private String contentType;
66 | private String characterEncoding = DEFAULT_CHARACTER_ENCODING;
67 | private Locale locale;
68 |
69 | NettyHttpServletResponse(ChannelHandlerContext ctx, NettyEmbeddedContext servletContext, HttpResponse response) {
70 | this.servletContext = servletContext;
71 | this.response = response;
72 | this.outputStream = new HttpResponseOutputStream(ctx, this);
73 | cookies = new ArrayList<>();
74 | }
75 |
76 | /**
77 | * Get a Netty {@link HttpResponse}, committing the {@link HttpServletResponse}.
78 | */
79 | public HttpResponse getNettyResponse() {
80 | if (committed) {
81 | return response;
82 | }
83 | committed = true;
84 | HttpHeaders headers = response.headers();
85 | if (null != contentType) {
86 | String value = null == characterEncoding ? contentType : contentType + "; charset=" + characterEncoding;
87 | headers.set(HttpHeaders.Names.CONTENT_TYPE, value);
88 | }
89 | CharSequence date = getFormattedDate();
90 | headers.set(HttpHeaders.Names.DATE, date);
91 | headers.set(HttpHeaders.Names.SERVER, servletContext.getServerInfoAscii());
92 | // TODO cookies
93 | return response;
94 | }
95 |
96 | @VisibleForTesting
97 | CharSequence getFormattedDate() {
98 | return HttpHeaders.newEntity(FORMAT.get().format(new Date()));
99 | }
100 |
101 | @Override
102 | public void addCookie(Cookie cookie) {
103 | cookies.add(cookie);
104 | }
105 |
106 | @Override
107 | public boolean containsHeader(String name) {
108 | return response.headers().contains(name);
109 | }
110 |
111 | @Override
112 | public String encodeURL(String url) {
113 | return null;
114 | }
115 |
116 | @Override
117 | public String encodeRedirectURL(String url) {
118 | return null;
119 | }
120 |
121 | @Override
122 | public String encodeUrl(String url) {
123 | return null;
124 | }
125 |
126 | @Override
127 | public String encodeRedirectUrl(String url) {
128 | return null;
129 | }
130 |
131 | @Override
132 | public void sendError(int sc, String msg) throws IOException {
133 | checkNotCommitted();
134 | response.setStatus(new HttpResponseStatus(sc, msg));
135 | }
136 |
137 | @Override
138 | public void sendError(int sc) throws IOException {
139 | checkNotCommitted();
140 | response.setStatus(HttpResponseStatus.valueOf(sc));
141 | }
142 |
143 | @Override
144 | public void sendRedirect(String location) throws IOException {
145 | checkNotCommitted();
146 | // TODO implement
147 | }
148 |
149 | @Override
150 | public void setDateHeader(String name, long date) {
151 | response.headers().set(name, date);
152 | }
153 |
154 | @Override
155 | public void addDateHeader(String name, long date) {
156 | response.headers().add(name, date);
157 | }
158 |
159 | @Override
160 | public void setHeader(String name, String value) {
161 | if (setHeaderField(name, value)) {
162 | return;
163 | }
164 | response.headers().set(name, value);
165 | }
166 |
167 | private boolean setHeaderField(String name, String value) {
168 | // Handle headers that shouldn't be set directly, and are instance fields
169 | char c = name.charAt(0);
170 | if ('C' == c || 'c' == c) {
171 | if (HttpHeaders.Names.CONTENT_TYPE.equalsIgnoreCase(name)) {
172 | setContentType(value);
173 | return true;
174 | }
175 | // TODO Content-Language?
176 | }
177 | return false;
178 | }
179 |
180 | @Override
181 | public void addHeader(String name, String value) {
182 | if (setHeaderField(name, value)) {
183 | return;
184 | }
185 | response.headers().add(name, value);
186 | }
187 |
188 | @Override
189 | public void setIntHeader(String name, int value) {
190 | response.headers().set(name, value);
191 | }
192 |
193 | @Override
194 | public void addIntHeader(String name, int value) {
195 | response.headers().add(name, value);
196 | }
197 |
198 | @Override
199 | public void setStatus(int sc) {
200 | response.setStatus(HttpResponseStatus.valueOf(sc));
201 | }
202 |
203 | @Override
204 | public void setStatus(int sc, String sm) {
205 | response.setStatus(new HttpResponseStatus(sc, sm));
206 | }
207 |
208 | @Override
209 | public int getStatus() {
210 | return response.status().code();
211 | }
212 |
213 | @Override
214 | public String getHeader(String name) {
215 | return response.headers().get(name);
216 | }
217 |
218 | @Override
219 | public Collection getHeaders(String name) {
220 | return response.headers().getAll(name);
221 | }
222 |
223 | @Override
224 | public Collection getHeaderNames() {
225 | return response.headers().names();
226 | }
227 |
228 | @Override
229 | public String getCharacterEncoding() {
230 | return characterEncoding;
231 | }
232 |
233 | @Override
234 | public String getContentType() {
235 | return contentType;
236 | }
237 |
238 | @Override
239 | public ServletOutputStream getOutputStream() throws IOException {
240 | checkState(!hasWriter(), "getWriter has already been called for this response");
241 | usingOutputStream = true;
242 | return outputStream;
243 | }
244 |
245 | @Override
246 | public PrintWriter getWriter() throws IOException {
247 | checkState(!usingOutputStream, "getOutputStream has already been called for this response");
248 | if (!hasWriter()) {
249 | writer = new PrintWriter(outputStream);
250 | }
251 | return writer;
252 | }
253 |
254 | @Override
255 | public void setCharacterEncoding(String charset) {
256 | if (hasWriter()) {
257 | return;
258 | }
259 | characterEncoding = charset;
260 | }
261 |
262 | @Override
263 | public void setContentType(String type) {
264 | if (isCommitted()) {
265 | return;
266 | }
267 | if (hasWriter()) {
268 | return;
269 | }
270 | if (null == type) {
271 | contentType = null;
272 | return;
273 | }
274 | MediaType mediaType = MediaType.parse(type);
275 | Optional charset = mediaType.charset();
276 | if (charset.isPresent()) {
277 | setCharacterEncoding(charset.get().name());
278 | }
279 | contentType = mediaType.type() + '/' + mediaType.subtype();
280 | }
281 |
282 | private boolean hasWriter() {
283 | return null != writer;
284 | }
285 |
286 | @Override
287 | public void setContentLength(int len) {
288 | HttpHeaders.setContentLength(response, len);
289 | }
290 |
291 | @Override
292 | public void setContentLengthLong(long len) {
293 | HttpHeaders.setContentLength(response, len);
294 | }
295 |
296 | @Override
297 | public void setBufferSize(int size) {
298 | checkNotCommitted();
299 | outputStream.setBufferSize(size);
300 | }
301 |
302 | @Override
303 | public int getBufferSize() {
304 | return outputStream.getBufferSize();
305 | }
306 |
307 | @Override
308 | public void flushBuffer() throws IOException {
309 | checkNotCommitted();
310 | outputStream.flush();
311 | }
312 |
313 | @Override
314 | public void resetBuffer() {
315 | checkNotCommitted();
316 | outputStream.resetBuffer();
317 | }
318 |
319 | @Override
320 | public boolean isCommitted() {
321 | return committed;
322 | }
323 |
324 | void checkNotCommitted() {
325 | checkState(!committed, "Cannot perform this operation after response has been committed");
326 | }
327 |
328 | @Override
329 | public void reset() {
330 | resetBuffer();
331 | usingOutputStream = false;
332 | writer = null;
333 | }
334 |
335 | @Override
336 | public void setLocale(Locale loc) {
337 | locale = loc;
338 | }
339 |
340 | @Override
341 | public Locale getLocale() {
342 | return null == locale ? DEFAULT_LOCALE : locale;
343 | }
344 | }
345 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyRequestDispatcher.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import javax.servlet.*;
21 | import java.io.IOException;
22 |
23 | /**
24 | * @author Danny Thomas
25 | */
26 | class NettyRequestDispatcher implements RequestDispatcher {
27 | private final ServletContext context;
28 | private final FilterChain filterChain;
29 |
30 | NettyRequestDispatcher(ServletContext context, FilterChain filterChain) {
31 | this.context = context;
32 | this.filterChain = filterChain;
33 | }
34 |
35 | @Override
36 | public void forward(ServletRequest request, ServletResponse response) throws ServletException, IOException {
37 | request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.FORWARD);
38 | // TODO implement
39 | }
40 |
41 | @Override
42 | public void include(ServletRequest request, ServletResponse response) throws ServletException, IOException {
43 | request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.INCLUDE);
44 | // TODO implement
45 | }
46 |
47 | void dispatch(ServletRequest request, ServletResponse response) throws ServletException, IOException {
48 | request.setAttribute(NettyHttpServletRequest.DISPATCHER_TYPE, DispatcherType.ASYNC);
49 | filterChain.doFilter(request, response);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/NettyServletRegistration.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import javax.servlet.*;
21 | import java.util.Collection;
22 | import java.util.Collections;
23 | import java.util.Set;
24 |
25 | /**
26 | * A {@link org.springframework.boot.context.embedded.netty.NettyEmbeddedContext} {@link javax.servlet.ServletRegistration}.
27 | *
28 | * @author Danny Thomas
29 | */
30 | class NettyServletRegistration extends AbstractNettyRegistration implements ServletRegistration.Dynamic {
31 | private volatile boolean initialised;
32 | private Servlet servlet;
33 |
34 | NettyServletRegistration(NettyEmbeddedContext context, String servletName, String className, Servlet servlet) {
35 | super(servletName, className, context);
36 | this.servlet = servlet;
37 | }
38 |
39 | public Servlet getServlet() throws ServletException {
40 | if (!initialised) {
41 | synchronized (this) {
42 | if (!initialised) {
43 | if (null == servlet) {
44 | try {
45 | servlet = (Servlet) Class.forName(getClassName()).newInstance();
46 | } catch (Exception e) {
47 | throw new ServletException(e);
48 | }
49 | }
50 | servlet.init(this);
51 | initialised = true;
52 | }
53 | }
54 | }
55 | return servlet;
56 | }
57 |
58 | @Override
59 | public void setLoadOnStartup(int loadOnStartup) {
60 |
61 | }
62 |
63 | @Override
64 | public Set setServletSecurity(ServletSecurityElement constraint) {
65 | return null;
66 | }
67 |
68 | @Override
69 | public void setMultipartConfig(MultipartConfigElement multipartConfig) {
70 |
71 | }
72 |
73 | @Override
74 | public void setRunAsRole(String roleName) {
75 |
76 | }
77 |
78 | @Override
79 | public Set addMapping(String... urlPatterns) {
80 | // TODO check for conflicts
81 |
82 | NettyEmbeddedContext context = getNettyContext();
83 | for (String urlPattern : urlPatterns) {
84 | context.addServletMapping(urlPattern, getName());
85 | }
86 | return Collections.emptySet();
87 | }
88 |
89 | @Override
90 | public Collection getMappings() {
91 | return null;
92 | }
93 |
94 | @Override
95 | public String getRunAsRole() {
96 | return null;
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/RequestDispatcherHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.channel.ChannelHandler;
21 | import io.netty.channel.ChannelHandlerContext;
22 | import io.netty.channel.SimpleChannelInboundHandler;
23 | import org.apache.commons.logging.Log;
24 | import org.apache.commons.logging.LogFactory;
25 |
26 | import javax.servlet.http.HttpServletRequest;
27 | import javax.servlet.http.HttpServletResponse;
28 |
29 | import static com.google.common.base.Preconditions.checkNotNull;
30 |
31 | /**
32 | * A {@link io.netty.channel.ChannelInboundHandler} that bridges to and from {@link HttpServletRequest}s and
33 | * {@link HttpServletResponse}s from Netty HTTP codec objects.
34 | *
35 | * @author Danny Thomas
36 | */
37 | @ChannelHandler.Sharable
38 | class RequestDispatcherHandler extends SimpleChannelInboundHandler {
39 | private final Log logger = LogFactory.getLog(getClass());
40 | private final NettyEmbeddedContext context;
41 |
42 | RequestDispatcherHandler(NettyEmbeddedContext context) {
43 | this.context = checkNotNull(context);
44 | }
45 |
46 | @Override
47 | public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
48 | ctx.flush();
49 | }
50 |
51 | @Override
52 | protected void channelRead0(ChannelHandlerContext ctx, NettyHttpServletRequest request) throws Exception {
53 | HttpServletResponse servletResponse = (HttpServletResponse) request.getServletResponse();
54 | try {
55 | NettyRequestDispatcher dispatcher = (NettyRequestDispatcher) context.getRequestDispatcher(request.getRequestURI());
56 | if (dispatcher == null) {
57 | servletResponse.sendError(404);
58 | return;
59 | }
60 | dispatcher.dispatch(request, servletResponse);
61 | } finally {
62 | if (!request.isAsyncStarted()) {
63 | servletResponse.getOutputStream().close();
64 | }
65 | }
66 | }
67 |
68 | @Override
69 | public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
70 | logger.error("Unexpected exception caught during request", cause);
71 | ctx.close();
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/ServletContentHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import io.netty.channel.ChannelHandlerContext;
21 | import io.netty.channel.ChannelInboundHandlerAdapter;
22 | import io.netty.handler.codec.http.*;
23 |
24 | /**
25 | * {@link io.netty.channel.ChannelInboundHandler} responsible for initial request handling, and getting received
26 | * {@link HttpContent} messages to the {@link HttpContentInputStream} for the request.
27 | */
28 | class ServletContentHandler extends ChannelInboundHandlerAdapter {
29 | private final NettyEmbeddedContext servletContext;
30 | private HttpContentInputStream inputStream; // FIXME this feels wonky, need a better approach
31 |
32 | ServletContentHandler(NettyEmbeddedContext servletContext) {
33 | this.servletContext = servletContext;
34 | }
35 |
36 | @Override
37 | public void channelActive(ChannelHandlerContext ctx) throws Exception {
38 | inputStream = new HttpContentInputStream(ctx.channel());
39 | }
40 |
41 | @Override
42 | public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
43 | if (msg instanceof HttpRequest) {
44 | HttpRequest request = (HttpRequest) msg;
45 | HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, false);
46 | HttpHeaders.setKeepAlive(response, HttpHeaders.isKeepAlive(request));
47 | NettyHttpServletResponse servletResponse = new NettyHttpServletResponse(ctx, servletContext, response);
48 | NettyHttpServletRequest servletRequest = new NettyHttpServletRequest(ctx, servletContext, request, servletResponse, inputStream);
49 | if (HttpHeaders.is100ContinueExpected(request)) {
50 | ctx.write(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE), ctx.voidPromise());
51 | }
52 | ctx.fireChannelRead(servletRequest);
53 | }
54 | if (msg instanceof HttpContent) {
55 | inputStream.addContent((HttpContent) msg);
56 | }
57 | }
58 |
59 | @Override
60 | public void channelInactive(ChannelHandlerContext ctx) throws Exception {
61 | inputStream.close();
62 | }
63 | }
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/SimpleFilterChain.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty;
19 |
20 | import javax.servlet.*;
21 | import java.io.IOException;
22 | import java.util.Iterator;
23 |
24 | import static com.google.common.base.Preconditions.checkNotNull;
25 |
26 | /**
27 | * A very simple {@link FilterChain} implementation.
28 | *
29 | * @author Danny Thomas
30 | */
31 | class SimpleFilterChain implements FilterChain {
32 | private final Iterator filterIterator;
33 | private final Servlet servlet;
34 |
35 | SimpleFilterChain(Servlet servlet, Iterable filters) throws ServletException {
36 | this.filterIterator = checkNotNull(filters).iterator();
37 | this.servlet = checkNotNull(servlet);
38 | }
39 |
40 | @Override
41 | public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
42 | if (filterIterator.hasNext()) {
43 | Filter filter = filterIterator.next();
44 | filter.doFilter(request, response, this);
45 | } else {
46 | servlet.service(request, response);
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/main/java/org/springframework/boot/context/embedded/netty/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | /**
19 | * Comment here.
20 | */
21 | package org.springframework.boot.context.embedded.netty;
--------------------------------------------------------------------------------
/src/test/groovy/org/springframework/boot/context/embedded/netty/HttpContentInputStreamTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty
19 |
20 | import com.google.common.base.Charsets
21 | import io.netty.buffer.Unpooled
22 | import io.netty.channel.Channel
23 | import io.netty.handler.codec.http.DefaultHttpContent
24 | import io.netty.handler.codec.http.LastHttpContent
25 | import spock.lang.Specification
26 |
27 | /**
28 | * Tests for {@link HttpContentInputStream}.
29 | */
30 | class HttpContentInputStreamTest extends Specification {
31 | def channel
32 | def stream
33 |
34 | def setup() {
35 | channel = Mock(Channel)
36 | stream = new HttpContentInputStream(channel)
37 | }
38 |
39 | def 'a read with a an empty last content returns -1'() {
40 | given:
41 | stream.addContent(LastHttpContent.EMPTY_LAST_CONTENT)
42 |
43 | expect:
44 | stream.read() == -1
45 | }
46 |
47 | def 'a read with an empty last content, for a non-active channel, returns -1'() {
48 | given:
49 | stream.addContent(LastHttpContent.EMPTY_LAST_CONTENT)
50 |
51 | expect:
52 | stream.read() == -1
53 | }
54 |
55 | def 'an attempt to read with a non-active channel, throws IOException'() {
56 | given:
57 | channel.isActive() >> false
58 |
59 | when:
60 | stream.read()
61 |
62 | then:
63 | thrown(IOException)
64 | }
65 |
66 | def 'expected number of bytes and content is read for a single content read'() {
67 | when:
68 | stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer("My hovercraft is full of eels.", Charsets.UTF_8)))
69 |
70 | then:
71 | def b = new byte[30]
72 | stream.read(b, 0, 30) == 30
73 | new String(b) == "My hovercraft is full of eels."
74 | }
75 |
76 | def 'the expected number of bytes and content is read for partial read of two component contents'() {
77 | when:
78 | stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer("My hovercraft is full of eels.", Charsets.UTF_8)))
79 | stream.addContent(new DefaultHttpContent(Unpooled.copiedBuffer(" I will not buy this record, it is scratched.", Charsets.UTF_8)))
80 |
81 | then:
82 | def b = new byte[75]
83 | stream.read(b, 0, 30) == 30
84 | stream.read(b, 30, 45) == 45
85 | new String(b) == "My hovercraft is full of eels. I will not buy this record, it is scratched."
86 | }
87 |
88 | def 'zero length read returns 0'() {
89 | expect:
90 | stream.read(new byte[0], 0, 0) == 0
91 | }
92 |
93 | def 'stream is not finished'() {
94 | expect:
95 | !stream.isFinished()
96 | }
97 |
98 | def 'stream is not ready'() {
99 | expect:
100 | !stream.isReady()
101 | }
102 |
103 | def 'stream has no available bytes'() {
104 | expect:
105 | stream.available() == 0
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/src/test/groovy/org/springframework/boot/context/embedded/netty/PackageSanityTest.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2014 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | package org.springframework.boot.context.embedded.netty
19 |
20 | import com.google.common.base.Predicate
21 | import com.google.common.testing.AbstractPackageSanityTests
22 | import io.netty.buffer.ByteBuf
23 | import io.netty.buffer.Unpooled
24 | import org.junit.Ignore
25 |
26 | import javax.annotation.Nullable
27 |
28 | /**
29 | * Sanity tests for {@link org.springframework.boot.context.embedded.netty}.
30 | */
31 | @Ignore
32 | // FIXME I've added a bunch of new classes that can't be instantiated automatically, that'll I'll need to add back here
33 | class PackageSanityTest extends AbstractPackageSanityTests {
34 | PackageSanityTest() {
35 | setDefault(ByteBuf, Unpooled.buffer())
36 | setDefault(NettyEmbeddedContext, new NettyEmbeddedContext("/", Thread.currentThread().getContextClassLoader(), "ServerInfo"))
37 | ignoreClasses(new Predicate>() {
38 | @Override
39 | boolean apply(@Nullable Class input) {
40 | input == AbstractNettyRegistration
41 | }
42 | })
43 | }
44 | }
45 |
--------------------------------------------------------------------------------