Initial Contribution
Signed-off-by: Jan Supol <jan.supol@oracle.com>
diff --git a/containers/glassfish/jersey-gf-ejb/pom.xml b/containers/glassfish/jersey-gf-ejb/pom.xml
new file mode 100644
index 0000000..4038ce7
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/pom.xml
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers.glassfish</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-gf-ejb</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-gf-ejb</name>
+
+ <description>Jersey EJB for GlassFish integration</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.jersey.ext.cdi</groupId>
+ <artifactId>jersey-cdi1x</artifactId>
+ <version>${project.version}</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>javax.ejb</groupId>
+ <artifactId>javax.ejb-api</artifactId>
+ <version>${ejb.version}</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>javax.interceptor</groupId>
+ <artifactId>javax.interceptor-api</artifactId>
+ <version>${javax.interceptor.version}</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.core</groupId>
+ <artifactId>jersey-server</artifactId>
+ <version>${project.version}</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.main.ejb</groupId>
+ <artifactId>ejb-container</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.main.common</groupId>
+ <artifactId>container-common</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <configuration>
+ <!--
+ Excluding only *.tests.* packages for this module. At least one class has to exist in non-excluded
+ packages to generate proper -javadoc.jar file. See https://jira.codehaus.org/browse/MJAVADOC-329
+ -->
+ <excludePackageNames>*.tests.*</excludePackageNames>
+ </configuration>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <!-- Explicitly set versions for packages from GlassFish to allow future uptake of GlassFish 5.x-->
+ <Import-Package>
+ com.sun.*;version="[4.0,6)",
+ org.glassfish.ejb.*;version="[4.0,6)",
+ org.glassfish.internal.*;version="[4.0,6)",
+ *
+ </Import-Package>
+ <_versionpolicy>[$(version;==;$(@)),$(version;+;$(@)))</_versionpolicy>
+ <_nodefaultversion>false</_nodefaultversion>
+ </instructions>
+ </configuration>
+ <executions>
+ <execution>
+ <id>osgi-bundle</id>
+ <phase>package</phase>
+ <goals>
+ <goal>bundle</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentInterceptor.java b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentInterceptor.java
new file mode 100644
index 0000000..26e6e8b
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentInterceptor.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.gf.ejb.internal;
+
+import javax.annotation.PostConstruct;
+import javax.interceptor.InvocationContext;
+
+import org.glassfish.jersey.ext.cdi1x.internal.CdiComponentProvider;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+
+/**
+ * EJB interceptor to inject Jersey specific stuff into EJB beans.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public final class EjbComponentInterceptor {
+
+ private final InjectionManager injectionManager;
+
+ /**
+ * Create new EJB component injection manager.
+ *
+ * @param injectionManager injection manager.
+ */
+ public EjbComponentInterceptor(final InjectionManager injectionManager) {
+ this.injectionManager = injectionManager;
+ }
+
+ @PostConstruct
+ private void inject(final InvocationContext context) throws Exception {
+
+ final Object beanInstance = context.getTarget();
+ injectionManager.inject(beanInstance, CdiComponentProvider.CDI_CLASS_ANALYZER);
+
+ // Invoke next interceptor in chain
+ context.proceed();
+ }
+}
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentProvider.java b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentProvider.java
new file mode 100644
index 0000000..8a652e3
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbComponentProvider.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.gf.ejb.internal;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.ext.ExceptionMapper;
+
+import javax.annotation.Priority;
+import javax.ejb.Local;
+import javax.ejb.Remote;
+import javax.inject.Singleton;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.Binding;
+import org.glassfish.jersey.internal.inject.Bindings;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+import org.glassfish.jersey.internal.inject.InstanceBinding;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.model.Invocable;
+import org.glassfish.jersey.server.spi.ComponentProvider;
+import org.glassfish.jersey.server.spi.internal.ResourceMethodInvocationHandlerProvider;
+
+import org.glassfish.ejb.deployment.descriptor.EjbBundleDescriptorImpl;
+import org.glassfish.ejb.deployment.descriptor.EjbDescriptor;
+import org.glassfish.internal.data.ApplicationInfo;
+import org.glassfish.internal.data.ApplicationRegistry;
+import org.glassfish.internal.data.ModuleInfo;
+
+import com.sun.ejb.containers.BaseContainer;
+import com.sun.ejb.containers.EjbContainerUtil;
+import com.sun.ejb.containers.EjbContainerUtilImpl;
+import com.sun.enterprise.config.serverbeans.Application;
+import com.sun.enterprise.config.serverbeans.Applications;
+
+/**
+ * EJB component provider.
+ *
+ * @author Paul Sandoz
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+@Priority(300)
+@SuppressWarnings("UnusedDeclaration")
+public final class EjbComponentProvider implements ComponentProvider, ResourceMethodInvocationHandlerProvider {
+
+ private static final Logger LOGGER = Logger.getLogger(EjbComponentProvider.class.getName());
+
+ private InitialContext initialContext;
+ private final List<String> libNames = new CopyOnWriteArrayList<>();
+
+ private boolean ejbInterceptorRegistered = false;
+
+ /**
+ * HK2 factory to provide EJB components obtained via JNDI lookup.
+ */
+ private static class EjbFactory<T> implements Supplier<T> {
+
+ final InitialContext ctx;
+ final Class<T> clazz;
+ final EjbComponentProvider ejbProvider;
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public T get() {
+ try {
+ return (T) lookup(ctx, clazz, clazz.getSimpleName(), ejbProvider);
+ } catch (NamingException ex) {
+ Logger.getLogger(ApplicationHandler.class.getName()).log(Level.SEVERE, null, ex);
+ return null;
+ }
+ }
+
+ public EjbFactory(Class<T> rawType, InitialContext ctx, EjbComponentProvider ejbProvider) {
+ this.clazz = rawType;
+ this.ctx = ctx;
+ this.ejbProvider = ejbProvider;
+ }
+ }
+
+ /**
+ * Annotations to determine EJB components.
+ */
+ private static final Set<String> EjbComponentAnnotations = Collections.unmodifiableSet(new HashSet<String>() {{
+ add("javax.ejb.Stateful");
+ add("javax.ejb.Stateless");
+ add("javax.ejb.Singleton");
+ }});
+
+ private InjectionManager injectionManager = null;
+
+ // ComponentProvider
+ @Override
+ public void initialize(final InjectionManager injectionManager) {
+ this.injectionManager = injectionManager;
+
+ InstanceBinding<EjbComponentProvider> descriptor = Bindings.service(EjbComponentProvider.this)
+ .to(ResourceMethodInvocationHandlerProvider.class);
+ this.injectionManager.register(descriptor);
+ }
+
+ private ApplicationInfo getApplicationInfo(EjbContainerUtil ejbUtil) throws NamingException {
+ ApplicationRegistry appRegistry = ejbUtil.getServices().getService(ApplicationRegistry.class);
+ Applications applications = ejbUtil.getServices().getService(Applications.class);
+ String appNamePrefix = (String) initialContext.lookup("java:app/AppName");
+ Set<String> appNames = appRegistry.getAllApplicationNames();
+ Set<String> disabledApps = new TreeSet<>();
+ for (String appName : appNames) {
+ if (appName.startsWith(appNamePrefix)) {
+ Application appDesc = applications.getApplication(appName);
+ if (appDesc != null && !ejbUtil.getDeployment().isAppEnabled(appDesc)) {
+ // skip disabled version of the app
+ disabledApps.add(appName);
+ } else {
+ return ejbUtil.getDeployment().get(appName);
+ }
+ }
+ }
+
+ // grab the latest one, there is no way to make
+ // sure which one the user is actually enabling,
+ // so use the best case, i.e. upgrade
+ Iterator<String> it = disabledApps.iterator();
+ String lastDisabledApp = null;
+ while (it.hasNext()) {
+ lastDisabledApp = it.next();
+ }
+ if (lastDisabledApp != null) {
+ return ejbUtil.getDeployment().get(lastDisabledApp);
+ }
+
+ throw new NamingException("Application Information Not Found");
+ }
+
+ private void registerEjbInterceptor() {
+ try {
+ final Object interceptor = new EjbComponentInterceptor(injectionManager);
+ initialContext = getInitialContext();
+ final EjbContainerUtil ejbUtil = EjbContainerUtilImpl.getInstance();
+ final ApplicationInfo appInfo = getApplicationInfo(ejbUtil);
+ final List<String> tempLibNames = new LinkedList<>();
+ for (ModuleInfo moduleInfo : appInfo.getModuleInfos()) {
+ final String jarName = moduleInfo.getName();
+ if (jarName.endsWith(".jar") || jarName.endsWith(".war")) {
+ final String moduleName = jarName.substring(0, jarName.length() - 4);
+ tempLibNames.add(moduleName);
+ final Object bundleDescriptor = moduleInfo.getMetaData(EjbBundleDescriptorImpl.class.getName());
+ if (bundleDescriptor instanceof EjbBundleDescriptorImpl) {
+ final Collection<EjbDescriptor> ejbs = ((EjbBundleDescriptorImpl) bundleDescriptor).getEjbs();
+
+ for (final EjbDescriptor ejb : ejbs) {
+ final BaseContainer ejbContainer = EjbContainerUtilImpl.getInstance().getContainer(ejb.getUniqueId());
+ try {
+ AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ @Override
+ public Object run() throws Exception {
+ final Method registerInterceptorMethod =
+ BaseContainer.class
+ .getDeclaredMethod("registerSystemInterceptor", java.lang.Object.class);
+ registerInterceptorMethod.setAccessible(true);
+
+ registerInterceptorMethod.invoke(ejbContainer, interceptor);
+ return null;
+ }
+ });
+ } catch (PrivilegedActionException pae) {
+ final Throwable cause = pae.getCause();
+ LOGGER.log(Level.WARNING,
+ LocalizationMessages.EJB_INTERCEPTOR_BINDING_WARNING(ejb.getEjbClassName()), cause);
+ }
+ }
+ }
+ }
+ }
+ libNames.addAll(tempLibNames);
+ final Object interceptorBinder = initialContext.lookup("java:org.glassfish.ejb.container.interceptor_binding_spi");
+ // Some implementations of InitialContext return null instead of
+ // throwing NamingException if there is no Object associated with
+ // the name
+ if (interceptorBinder == null) {
+ throw new IllegalStateException(LocalizationMessages.EJB_INTERCEPTOR_BIND_API_NOT_AVAILABLE());
+ }
+
+ try {
+ AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ @Override
+ public Object run() throws Exception {
+ Method interceptorBinderMethod = interceptorBinder.getClass()
+ .getMethod("registerInterceptor", java.lang.Object.class);
+
+ interceptorBinderMethod.invoke(interceptorBinder, interceptor);
+ EjbComponentProvider.this.ejbInterceptorRegistered = true;
+ LOGGER.log(Level.CONFIG, LocalizationMessages.EJB_INTERCEPTOR_BOUND());
+ return null;
+ }
+ });
+ } catch (PrivilegedActionException pae) {
+ throw new IllegalStateException(LocalizationMessages.EJB_INTERCEPTOR_CONFIG_ERROR(), pae.getCause());
+ }
+
+ } catch (NamingException ex) {
+ throw new IllegalStateException(LocalizationMessages.EJB_INTERCEPTOR_BIND_API_NOT_AVAILABLE(), ex);
+ } catch (LinkageError ex) {
+ throw new IllegalStateException(LocalizationMessages.EJB_INTERCEPTOR_CONFIG_LINKAGE_ERROR(), ex);
+ }
+ }
+
+ // ComponentProvider
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean bind(Class<?> component, Set<Class<?>> providerContracts) {
+
+ if (LOGGER.isLoggable(Level.FINE)) {
+ LOGGER.fine(LocalizationMessages.EJB_CLASS_BEING_CHECKED(component));
+ }
+
+ if (injectionManager == null) {
+ throw new IllegalStateException(LocalizationMessages.EJB_COMPONENT_PROVIDER_NOT_INITIALIZED_PROPERLY());
+ }
+
+ if (!isEjbComponent(component)) {
+ return false;
+ }
+
+ if (!ejbInterceptorRegistered) {
+ registerEjbInterceptor();
+ }
+
+ Binding binding = Bindings.supplier(new EjbFactory(component, initialContext, EjbComponentProvider.this))
+ .to(component)
+ .to(providerContracts);
+ injectionManager.register(binding);
+
+ if (LOGGER.isLoggable(Level.CONFIG)) {
+ LOGGER.config(LocalizationMessages.EJB_CLASS_BOUND_WITH_CDI(component));
+ }
+
+ return true;
+ }
+
+ @Override
+ public void done() {
+ registerEjbExceptionMapper();
+ }
+
+ private void registerEjbExceptionMapper() {
+ injectionManager.register(new AbstractBinder() {
+ @Override
+ protected void configure() {
+ bind(EjbExceptionMapper.class).to(ExceptionMapper.class).in(Singleton.class);
+ }
+ });
+ }
+
+ private boolean isEjbComponent(Class<?> component) {
+ for (Annotation a : component.getAnnotations()) {
+ if (EjbComponentAnnotations.contains(a.annotationType().getName())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public InvocationHandler create(Invocable method) {
+
+ final Class<?> resourceClass = method.getHandler().getHandlerClass();
+
+ if (resourceClass == null || !isEjbComponent(resourceClass)) {
+ return null;
+ }
+
+ final Method handlingMethod = method.getDefinitionMethod();
+
+ for (Class iFace : remoteAndLocalIfaces(resourceClass)) {
+ try {
+ final Method iFaceMethod = iFace.getDeclaredMethod(handlingMethod.getName(), handlingMethod.getParameterTypes());
+ if (iFaceMethod != null) {
+ return new InvocationHandler() {
+ @Override
+ public Object invoke(Object target, Method ignored, Object[] args)
+ throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+ return iFaceMethod.invoke(target, args);
+ }
+ };
+ }
+ } catch (NoSuchMethodException | SecurityException ex) {
+ logLookupException(handlingMethod, resourceClass, iFace, ex);
+ }
+ }
+ return null;
+ }
+
+ private void logLookupException(final Method method, final Class<?> component, Class<?> iFace, Exception ex) {
+ LOGGER.log(
+ Level.WARNING,
+ LocalizationMessages.EJB_INTERFACE_HANDLING_METHOD_LOOKUP_EXCEPTION(method, component, iFace), ex);
+ }
+
+ private List<Class> remoteAndLocalIfaces(final Class<?> resourceClass) {
+ final List<Class> allLocalOrRemoteIfaces = new LinkedList<>();
+ if (resourceClass.isAnnotationPresent(Remote.class)) {
+ allLocalOrRemoteIfaces.addAll(Arrays.asList(resourceClass.getAnnotation(Remote.class).value()));
+ }
+ if (resourceClass.isAnnotationPresent(Local.class)) {
+ allLocalOrRemoteIfaces.addAll(Arrays.asList(resourceClass.getAnnotation(Local.class).value()));
+ }
+ for (Class<?> i : resourceClass.getInterfaces()) {
+ if (i.isAnnotationPresent(Remote.class) || i.isAnnotationPresent(Local.class)) {
+ allLocalOrRemoteIfaces.add(i);
+ }
+ }
+ return allLocalOrRemoteIfaces;
+ }
+
+ private static InitialContext getInitialContext() {
+ try {
+ // Deployment on Google App Engine will
+ // result in a LinkageError
+ return new InitialContext();
+ } catch (Exception ex) {
+ throw new IllegalStateException(LocalizationMessages.INITIAL_CONTEXT_NOT_AVAILABLE(), ex);
+ }
+ }
+
+ private static Object lookup(InitialContext ic, Class<?> c, String name, EjbComponentProvider provider)
+ throws NamingException {
+ try {
+ return lookupSimpleForm(ic, name, provider);
+ } catch (NamingException ex) {
+ LOGGER.log(Level.WARNING, LocalizationMessages.EJB_CLASS_SIMPLE_LOOKUP_FAILED(c.getName()), ex);
+
+ return lookupFullyQualifiedForm(ic, c, name, provider);
+ }
+ }
+
+ private static Object lookupSimpleForm(InitialContext ic, String name, EjbComponentProvider provider) throws NamingException {
+ if (provider.libNames.isEmpty()) {
+ String jndiName = "java:module/" + name;
+ return ic.lookup(jndiName);
+ } else {
+ NamingException ne = null;
+ for (String moduleName : provider.libNames) {
+ String jndiName = "java:app/" + moduleName + "/" + name;
+ Object result;
+ try {
+ result = ic.lookup(jndiName);
+ if (result != null) {
+ return result;
+ }
+ } catch (NamingException e) {
+ ne = e;
+ }
+ }
+ throw (ne != null) ? ne : new NamingException();
+ }
+ }
+
+ private static Object lookupFullyQualifiedForm(InitialContext ic, Class<?> c, String name, EjbComponentProvider provider)
+ throws NamingException {
+ if (provider.libNames.isEmpty()) {
+ String jndiName = "java:module/" + name + "!" + c.getName();
+ return ic.lookup(jndiName);
+ } else {
+ NamingException ne = null;
+ for (String moduleName : provider.libNames) {
+ String jndiName = "java:app/" + moduleName + "/" + name + "!" + c.getName();
+ Object result;
+ try {
+ result = ic.lookup(jndiName);
+ if (result != null) {
+ return result;
+ }
+ } catch (NamingException e) {
+ ne = e;
+ }
+ }
+ throw (ne != null) ? ne : new NamingException();
+ }
+ }
+}
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbExceptionMapper.java b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbExceptionMapper.java
new file mode 100644
index 0000000..1121c41
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/EjbExceptionMapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.gf.ejb.internal;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.ExceptionMapper;
+
+import javax.ejb.EJBException;
+import javax.inject.Inject;
+import javax.inject.Provider;
+
+import org.glassfish.jersey.spi.ExceptionMappers;
+import org.glassfish.jersey.spi.ExtendedExceptionMapper;
+
+/**
+ * Helper class to handle exceptions wrapped by the EJB container with EJBException.
+ * If this mapper was not registered, no {@link WebApplicationException}
+ * would end up mapped to the corresponding response.
+ *
+ * @author Paul Sandoz
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public class EjbExceptionMapper implements ExtendedExceptionMapper<EJBException> {
+
+ private final Provider<ExceptionMappers> mappers;
+
+ /**
+ * Create new EJB exception mapper.
+ *
+ * @param mappers utility to find mapper delegate.
+ */
+ @Inject
+ public EjbExceptionMapper(Provider<ExceptionMappers> mappers) {
+ this.mappers = mappers;
+ }
+
+ @Override
+ public Response toResponse(EJBException exception) {
+ return causeToResponse(exception);
+ }
+
+ @Override
+ public boolean isMappable(EJBException exception) {
+ try {
+ return (causeToResponse(exception) != null);
+ } catch (Throwable ignored) {
+ return false;
+ }
+ }
+
+ private Response causeToResponse(EJBException exception) {
+
+ final Exception cause = exception.getCausedByException();
+
+ if (cause != null) {
+
+ final ExceptionMapper mapper = mappers.get().findMapping(cause);
+ if (mapper != null && mapper != this) {
+
+ return mapper.toResponse(cause);
+
+ } else if (cause instanceof WebApplicationException) {
+
+ return ((WebApplicationException) cause).getResponse();
+ }
+ }
+ return null;
+ }
+}
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/package-info.java b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/package-info.java
new file mode 100644
index 0000000..700cfe7
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/java/org/glassfish/jersey/gf/ejb/internal/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey internal package supporting Jersey EJB injections in Glassfish 4 environment.
+ */
+package org.glassfish.jersey.gf.ejb.internal;
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ComponentProvider b/containers/glassfish/jersey-gf-ejb/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ComponentProvider
new file mode 100644
index 0000000..2db13b7
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ComponentProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.gf.ejb.internal.EjbComponentProvider
diff --git a/containers/glassfish/jersey-gf-ejb/src/main/resources/org/glassfish/jersey/gf/ejb/internal/localization.properties b/containers/glassfish/jersey-gf-ejb/src/main/resources/org/glassfish/jersey/gf/ejb/internal/localization.properties
new file mode 100644
index 0000000..95bbf1c
--- /dev/null
+++ b/containers/glassfish/jersey-gf-ejb/src/main/resources/org/glassfish/jersey/gf/ejb/internal/localization.properties
@@ -0,0 +1,29 @@
+#
+# Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+initial.context.not.available=InitialContext not found. JAX-RS EJB support is not available.
+ejb.interceptor.bind.api.not.available=The EJB interceptor binding API is not available. JAX-RS EJB integration can not be supported.
+ejb.interceptor.bind.api.non.conformant=The EJB interceptor binding API does not conform to what is expected. JAX-RS EJB integration can not be supported.
+ejb.interceptor.binding.warning=Could not bind EJB intercetor for class, {0}.
+ejb.interceptor.bound=The Jersey EJB interceptor is bound. JAX-RS EJB integration support is enabled.
+ejb.interceptor.config.error=Error when configuring to use the EJB interceptor binding API. JAX-RS EJB integration can not be supported.
+ejb.interceptor.config.security.error=Security issue when configuring to use the EJB interceptor binding API. JAX-RS EJB support is not available.
+ejb.interceptor.config.linkage.error=Linkage error when configuring to use the EJB interceptor binding API. JAX-RS EJB integration can not be supported.
+ejb.component.provider.not.initialized.properly=EJB component provider has not been initialized properly.
+ejb.class.simple.lookup.failed=An instance of EJB class, {0}, could not be looked up using simple form name. Attempting to look up using the fully-qualified form name.
+ejb.interface.handling.method.lookup.exception=Exception thrown when trying to lookup actual handling method, {0}, for EJB type, {1}, using interface {2}.
+ejb.class.being.checked=Class, {0}, is being checked with Jersey EJB component provider.
+ejb.class.bound.with.cdi=Class, {0}, has been bound by Jersey EJB component provider.
diff --git a/containers/glassfish/pom.xml b/containers/glassfish/pom.xml
new file mode 100644
index 0000000..c10d92e
--- /dev/null
+++ b/containers/glassfish/pom.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <groupId>org.glassfish.jersey.containers.glassfish</groupId>
+ <artifactId>project</artifactId>
+ <packaging>pom</packaging>
+ <name>jersey-glassfish-support</name>
+
+ <description>Jersey GlassFish container providers umbrella project module</description>
+
+ <modules>
+ <module>jersey-gf-ejb</module>
+ </modules>
+
+</project>
diff --git a/containers/grizzly2-http/pom.xml b/containers/grizzly2-http/pom.xml
new file mode 100644
index 0000000..49e75e5
--- /dev/null
+++ b/containers/grizzly2-http/pom.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-grizzly2-http</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-grizzly2-http</name>
+
+ <description>Grizzly 2 Http Container.</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.grizzly</groupId>
+ <artifactId>grizzly-http-server</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ </plugins>
+
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ </build>
+
+</project>
diff --git a/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainer.java b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainer.java
new file mode 100644
index 0000000..8c9815d
--- /dev/null
+++ b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainer.java
@@ -0,0 +1,485 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.grizzly2.httpserver;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.Principal;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.SecurityContext;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+
+import org.glassfish.jersey.grizzly2.httpserver.internal.LocalizationMessages;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.ReferencingFactory;
+import org.glassfish.jersey.internal.util.ExtendedLogger;
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.process.internal.RequestScoped;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.ServerProperties;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+import org.glassfish.grizzly.CompletionHandler;
+import org.glassfish.grizzly.http.server.HttpHandler;
+import org.glassfish.grizzly.http.server.Request;
+import org.glassfish.grizzly.http.server.Response;
+
+/**
+ * Jersey {@code Container} implementation based on Grizzly {@link org.glassfish.grizzly.http.server.HttpHandler}.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class GrizzlyHttpContainer extends HttpHandler implements Container {
+
+ private static final ExtendedLogger logger =
+ new ExtendedLogger(Logger.getLogger(GrizzlyHttpContainer.class.getName()), Level.FINEST);
+
+ private final Type RequestTYPE = (new GenericType<Ref<Request>>() { }).getType();
+ private final Type ResponseTYPE = (new GenericType<Ref<Response>>() { }).getType();
+
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR}.
+ * If {@code true} method {@link org.glassfish.grizzly.http.server.Response#setStatus} is used over
+ * {@link org.glassfish.grizzly.http.server.Response#sendError}.
+ */
+ private boolean configSetStatusOverSendError;
+
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#REDUCE_CONTEXT_PATH_SLASHES_ENABLED}.
+ * If {@code true} method {@link org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpContainer#getRequestUri(Request)}
+ * will reduce the of leading context-path slashes to only one.
+ */
+ private boolean configReduceContextPathSlashesEnabled;
+
+ /**
+ * Referencing factory for Grizzly request.
+ */
+ private static class GrizzlyRequestReferencingFactory extends ReferencingFactory<Request> {
+
+ @Inject
+ public GrizzlyRequestReferencingFactory(final Provider<Ref<Request>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * Referencing factory for Grizzly response.
+ */
+ private static class GrizzlyResponseReferencingFactory extends ReferencingFactory<Response> {
+
+ @Inject
+ public GrizzlyResponseReferencingFactory(final Provider<Ref<Response>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * An internal binder to enable Grizzly HTTP container specific types injection.
+ * <p/>
+ * This binder allows to inject underlying Grizzly HTTP request and response instances.
+ * Note that since Grizzly {@code Request} class is not proxiable as it does not expose an empty constructor,
+ * the injection of Grizzly request instance into singleton JAX-RS and Jersey providers is only supported via
+ * {@link javax.inject.Provider injection provider}.
+ */
+ static class GrizzlyBinder extends AbstractBinder {
+
+ @Override
+ protected void configure() {
+ bindFactory(GrizzlyRequestReferencingFactory.class).to(Request.class)
+ .proxy(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Request>referenceFactory()).to(new GenericType<Ref<Request>>() {})
+ .in(RequestScoped.class);
+
+ bindFactory(GrizzlyResponseReferencingFactory.class).to(Response.class)
+ .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Response>referenceFactory()).to(new GenericType<Ref<Response>>() {})
+ .in(RequestScoped.class);
+ }
+ }
+
+ private static final CompletionHandler<Response> EMPTY_COMPLETION_HANDLER = new CompletionHandler<Response>() {
+
+ @Override
+ public void cancelled() {
+ // no-op
+ }
+
+ @Override
+ public void failed(final Throwable throwable) {
+ // no-op
+ }
+
+ @Override
+ public void completed(final Response result) {
+ // no-op
+ }
+
+ @Override
+ public void updated(final Response result) {
+ // no-op
+ }
+ };
+
+ private static final class ResponseWriter implements ContainerResponseWriter {
+
+ private final String name;
+ private final Response grizzlyResponse;
+ private final boolean configSetStatusOverSendError;
+
+ ResponseWriter(final Response response, final boolean configSetStatusOverSendError) {
+ this.grizzlyResponse = response;
+ this.configSetStatusOverSendError = configSetStatusOverSendError;
+
+ if (logger.isDebugLoggable()) {
+ this.name = "ResponseWriter {" + "id=" + UUID.randomUUID().toString() + ", grizzlyResponse="
+ + grizzlyResponse.hashCode() + '}';
+ logger.debugLog("{0} - init", name);
+ } else {
+ this.name = "ResponseWriter";
+ }
+ }
+
+ @Override
+ public String toString() {
+ return name;
+ }
+
+ @Override
+ public void commit() {
+ try {
+ if (grizzlyResponse.isSuspended()) {
+ grizzlyResponse.resume();
+ }
+ } finally {
+ logger.debugLog("{0} - commit() called", name);
+ }
+ }
+
+ @Override
+ public boolean suspend(final long timeOut, final TimeUnit timeUnit, final TimeoutHandler timeoutHandler) {
+ try {
+ grizzlyResponse.suspend(timeOut, timeUnit, EMPTY_COMPLETION_HANDLER,
+ new org.glassfish.grizzly.http.server.TimeoutHandler() {
+
+ @Override
+ public boolean onTimeout(final Response response) {
+ if (timeoutHandler != null) {
+ timeoutHandler.onTimeout(ResponseWriter.this);
+ }
+
+ // TODO should we return true in some cases instead?
+ // Returning false relies on the fact that the timeoutHandler will resume the response.
+ return false;
+ }
+ }
+ );
+ return true;
+ } catch (final IllegalStateException ex) {
+ return false;
+ } finally {
+ logger.debugLog("{0} - suspend(...) called", name);
+ }
+ }
+
+ @Override
+ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit) throws IllegalStateException {
+ try {
+ grizzlyResponse.getSuspendContext().setTimeout(timeOut, timeUnit);
+ } finally {
+ logger.debugLog("{0} - setTimeout(...) called", name);
+ }
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(final long contentLength,
+ final ContainerResponse context)
+ throws ContainerException {
+ try {
+ final javax.ws.rs.core.Response.StatusType statusInfo = context.getStatusInfo();
+ if (statusInfo.getReasonPhrase() == null) {
+ grizzlyResponse.setStatus(statusInfo.getStatusCode());
+ } else {
+ grizzlyResponse.setStatus(statusInfo.getStatusCode(), statusInfo.getReasonPhrase());
+ }
+
+ grizzlyResponse.setContentLengthLong(contentLength);
+
+ for (final Map.Entry<String, List<String>> e : context.getStringHeaders().entrySet()) {
+ for (final String value : e.getValue()) {
+ grizzlyResponse.addHeader(e.getKey(), value);
+ }
+ }
+
+ return grizzlyResponse.getOutputStream();
+ } finally {
+ logger.debugLog("{0} - writeResponseStatusAndHeaders() called", name);
+ }
+ }
+
+ @Override
+ @SuppressWarnings("MagicNumber")
+ public void failure(final Throwable error) {
+ try {
+ if (!grizzlyResponse.isCommitted()) {
+ try {
+ if (configSetStatusOverSendError) {
+ grizzlyResponse.reset();
+ grizzlyResponse.setStatus(500, "Request failed.");
+ } else {
+ grizzlyResponse.sendError(500, "Request failed.");
+ }
+ } catch (final IllegalStateException ex) {
+ // a race condition externally committing the response can still occur...
+ logger.log(Level.FINER, "Unable to reset failed response.", ex);
+ } catch (final IOException ex) {
+ throw new ContainerException(
+ LocalizationMessages.EXCEPTION_SENDING_ERROR_RESPONSE(500, "Request failed."),
+ ex);
+ }
+ }
+ } finally {
+ logger.debugLog("{0} - failure(...) called", name);
+ rethrow(error);
+ }
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return true;
+ }
+
+ /**
+ * Rethrow the original exception as required by JAX-RS, 3.3.4
+ *
+ * @param error throwable to be re-thrown
+ */
+ private void rethrow(final Throwable error) {
+ if (error instanceof RuntimeException) {
+ throw (RuntimeException) error;
+ } else {
+ throw new ContainerException(error);
+ }
+ }
+ }
+
+ private volatile ApplicationHandler appHandler;
+
+ /**
+ * Create a new Grizzly HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Grizzly HTTP container.
+ */
+ /* package */ GrizzlyHttpContainer(final Application application) {
+ this.appHandler = new ApplicationHandler(application, new GrizzlyBinder());
+ cacheConfigSetStatusOverSendError();
+ cacheConfigEnableLeadingContextPathSlashes();
+ }
+
+ /**
+ * Create a new Grizzly HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Grizzly HTTP container.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ */
+ /* package */ GrizzlyHttpContainer(final Application application, final Object parentContext) {
+ this.appHandler = new ApplicationHandler(application, new GrizzlyBinder(), parentContext);
+ cacheConfigSetStatusOverSendError();
+ cacheConfigEnableLeadingContextPathSlashes();
+ }
+
+ @Override
+ public void start() {
+ super.start();
+ appHandler.onStartup(this);
+ }
+
+ @Override
+ public void service(final Request request, final Response response) {
+ final ResponseWriter responseWriter = new ResponseWriter(response, configSetStatusOverSendError);
+ try {
+ logger.debugLog("GrizzlyHttpContainer.service(...) started");
+ URI baseUri = getBaseUri(request);
+ URI requestUri = getRequestUri(request);
+ final ContainerRequest requestContext = new ContainerRequest(baseUri,
+ requestUri, request.getMethod().getMethodString(),
+ getSecurityContext(request), new GrizzlyRequestPropertiesDelegate(request));
+ requestContext.setEntityStream(request.getInputStream());
+ for (final String headerName : request.getHeaderNames()) {
+ requestContext.headers(headerName, request.getHeaders(headerName));
+ }
+ requestContext.setWriter(responseWriter);
+
+ requestContext.setRequestScopedInitializer(injectionManager -> {
+ injectionManager.<Ref<Request>>getInstance(RequestTYPE).set(request);
+ injectionManager.<Ref<Response>>getInstance(ResponseTYPE).set(response);
+ });
+ appHandler.handle(requestContext);
+ } finally {
+ logger.debugLog("GrizzlyHttpContainer.service(...) finished");
+ }
+ }
+
+ private boolean containsContextPath(Request request) {
+ return request.getContextPath() != null && request.getContextPath().length() > 0;
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return appHandler.getConfiguration();
+ }
+
+ @Override
+ public void reload() {
+ reload(appHandler.getConfiguration());
+ }
+
+ @Override
+ public void reload(final ResourceConfig configuration) {
+ appHandler.onShutdown(this);
+
+ appHandler = new ApplicationHandler(configuration, new GrizzlyBinder());
+ appHandler.onReload(this);
+ appHandler.onStartup(this);
+ cacheConfigSetStatusOverSendError();
+ cacheConfigEnableLeadingContextPathSlashes();
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return appHandler;
+ }
+
+ @Override
+ public void destroy() {
+ super.destroy();
+ appHandler.onShutdown(this);
+ appHandler = null;
+ }
+
+ private SecurityContext getSecurityContext(final Request request) {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return false;
+ }
+
+ @Override
+ public boolean isSecure() {
+ return request.isSecure();
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return request.getUserPrincipal();
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return request.getAuthType();
+ }
+ };
+ }
+
+ private URI getBaseUri(final Request request) {
+ try {
+ return new URI(request.getScheme(), null, request.getServerName(),
+ request.getServerPort(), getBasePath(request), null, null);
+ } catch (final URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getBasePath(final Request request) {
+ final String contextPath = request.getContextPath();
+
+ if (contextPath == null || contextPath.isEmpty()) {
+ return "/";
+ } else if (contextPath.charAt(contextPath.length() - 1) != '/') {
+ return contextPath + "/";
+ } else {
+ return contextPath;
+ }
+ }
+
+ private URI getRequestUri(final Request request) {
+ try {
+ final String serverAddress = getServerAddress(request);
+
+ String uri;
+ if (configReduceContextPathSlashesEnabled && containsContextPath(request)) {
+ uri = ContainerUtils.reduceLeadingSlashes(request.getRequestURI());
+ } else {
+ uri = request.getRequestURI();
+ }
+
+ final String queryString = request.getQueryString();
+ if (queryString != null) {
+ uri = uri + "?" + ContainerUtils.encodeUnsafeCharacters(queryString);
+ }
+
+ return new URI(serverAddress + uri);
+ } catch (URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getServerAddress(final Request request) throws URISyntaxException {
+ return new URI(request.getScheme(), null, request.getServerName(), request.getServerPort(), null, null, null).toString();
+ }
+
+ /**
+ * The method reads and caches value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR} for future purposes.
+ */
+ private void cacheConfigSetStatusOverSendError() {
+ this.configSetStatusOverSendError = ServerProperties.getValue(getConfiguration().getProperties(),
+ ServerProperties.RESPONSE_SET_STATUS_OVER_SEND_ERROR, false, Boolean.class);
+ }
+
+ /**
+ * The method reads and caches value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#REDUCE_CONTEXT_PATH_SLASHES_ENABLED} for future purposes.
+ */
+ private void cacheConfigEnableLeadingContextPathSlashes() {
+ this.configReduceContextPathSlashesEnabled = ServerProperties.getValue(getConfiguration().getProperties(),
+ ServerProperties.REDUCE_CONTEXT_PATH_SLASHES_ENABLED, false, Boolean.class);
+ }
+}
diff --git a/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainerProvider.java b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainerProvider.java
new file mode 100644
index 0000000..4d14227
--- /dev/null
+++ b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpContainerProvider.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.grizzly2.httpserver;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Application;
+
+import org.glassfish.jersey.server.spi.ContainerProvider;
+
+import org.glassfish.grizzly.http.server.HttpHandler;
+
+/**
+ * Container provider for containers based on Grizzly {@link org.glassfish.grizzly.http.server.HttpHandler}.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class GrizzlyHttpContainerProvider implements ContainerProvider {
+
+ @Override
+ public <T> T createContainer(Class<T> type, Application application) throws ProcessingException {
+ if (HttpHandler.class == type || GrizzlyHttpContainer.class == type) {
+ return type.cast(new GrizzlyHttpContainer(application));
+ }
+
+ return null;
+ }
+}
diff --git a/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpServerFactory.java b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpServerFactory.java
new file mode 100644
index 0000000..fed3ec7
--- /dev/null
+++ b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyHttpServerFactory.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.grizzly2.httpserver;
+
+import java.io.IOException;
+import java.net.URI;
+
+import javax.ws.rs.ProcessingException;
+
+import org.glassfish.jersey.grizzly2.httpserver.internal.LocalizationMessages;
+import org.glassfish.jersey.internal.guava.ThreadFactoryBuilder;
+import org.glassfish.jersey.process.JerseyProcessingUncaughtExceptionHandler;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.Container;
+
+import org.glassfish.grizzly.http.server.HttpHandler;
+import org.glassfish.grizzly.http.server.HttpHandlerRegistration;
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.glassfish.grizzly.http.server.NetworkListener;
+import org.glassfish.grizzly.http.server.ServerConfiguration;
+import org.glassfish.grizzly.ssl.SSLEngineConfigurator;
+import org.glassfish.grizzly.utils.Charsets;
+
+/**
+ * Factory for creating Grizzly Http Server.
+ * <p>
+ * Should you need to fine tune the underlying Grizzly transport layer, you can obtain direct access to the corresponding
+ * Grizzly structures with <tt>server.getListener("grizzly").getTransport()</tt>. To make certain options take effect,
+ * you need to work with an inactive HttpServer instance (that is the one that has not been started yet).
+ * To obtain such an instance, use one of the below factory methods with {@code start} parameter set to {@code false}.
+ * When the {@code start} parameter is not present, the factory method returns an already started instance.
+ * </p>
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ * @see HttpServer
+ * @see GrizzlyHttpContainer
+ */
+public final class GrizzlyHttpServerFactory {
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri uri on which the {@link ApplicationHandler} will be deployed. Only first path segment will be used as
+ * context path, the rest will be ignored.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri) {
+ return createHttpServer(uri, (GrizzlyHttpContainer) null, false, null, true);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri uri on which the {@link ApplicationHandler} will be deployed. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param start if set to false, server will not get started, which allows to configure the underlying transport
+ * layer, see above for details.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri, final boolean start) {
+ return createHttpServer(uri, (GrizzlyHttpContainer) null, false, null, start);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri URI on which the Jersey web application will be deployed. Only first path segment will be
+ * used as context path, the rest will be ignored.
+ * @param configuration web application configuration.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration) {
+ return createHttpServer(
+ uri,
+ new GrizzlyHttpContainer(configuration),
+ false,
+ null,
+ true
+ );
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri URI on which the Jersey web application will be deployed. Only first path segment will be
+ * used as context path, the rest will be ignored.
+ * @param configuration web application configuration.
+ * @param start if set to false, server will not get started, which allows to configure the underlying
+ * transport layer, see above for details.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration, final boolean start) {
+ return createHttpServer(
+ uri,
+ new GrizzlyHttpContainer(configuration),
+ false,
+ null,
+ start);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri URI on which the Jersey web application will be deployed. Only first path segment
+ * will be used as context path, the rest will be ignored.
+ * @param configuration web application configuration.
+ * @param secure used for call {@link NetworkListener#setSecure(boolean)}.
+ * @param sslEngineConfigurator Ssl settings to be passed to {@link NetworkListener#setSSLEngineConfig}.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri,
+ final ResourceConfig configuration,
+ final boolean secure,
+ final SSLEngineConfigurator sslEngineConfigurator) {
+ return createHttpServer(
+ uri,
+ new GrizzlyHttpContainer(configuration),
+ secure,
+ sslEngineConfigurator,
+ true);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri URI on which the Jersey web application will be deployed. Only first path segment
+ * will be used as context path, the rest will be ignored.
+ * @param configuration web application configuration.
+ * @param secure used for call {@link NetworkListener#setSecure(boolean)}.
+ * @param sslEngineConfigurator Ssl settings to be passed to {@link NetworkListener#setSSLEngineConfig}.
+ * @param start if set to false, server will not get started, which allows to configure the
+ * underlying transport, see above for details.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ */
+ public static HttpServer createHttpServer(final URI uri,
+ final ResourceConfig configuration,
+ final boolean secure,
+ final SSLEngineConfigurator sslEngineConfigurator,
+ final boolean start) {
+ return createHttpServer(
+ uri,
+ new GrizzlyHttpContainer(configuration),
+ secure,
+ sslEngineConfigurator,
+ start);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri uri on which the {@link ApplicationHandler} will be deployed. Only first path
+ * segment will be used as context path, the rest will be ignored.
+ * @param config web application configuration.
+ * @param secure used for call {@link NetworkListener#setSecure(boolean)}.
+ * @param sslEngineConfigurator Ssl settings to be passed to {@link NetworkListener#setSSLEngineConfig}.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ * @see GrizzlyHttpContainer
+ * @since 2.12
+ */
+ public static HttpServer createHttpServer(final URI uri,
+ final ResourceConfig config,
+ final boolean secure,
+ final SSLEngineConfigurator sslEngineConfigurator,
+ final Object parentContext) {
+ return createHttpServer(uri, new GrizzlyHttpContainer(config, parentContext), secure, sslEngineConfigurator,
+ true);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri uri on which the {@link ApplicationHandler} will be deployed. Only first path
+ * segment will be used as context path, the rest will be ignored.
+ * @param config web application configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ * @see GrizzlyHttpContainer
+ * @since 2.12
+ */
+ public static HttpServer createHttpServer(final URI uri,
+ final ResourceConfig config,
+ final Object parentContext) {
+ return createHttpServer(uri, new GrizzlyHttpContainer(config, parentContext), false, null, true);
+ }
+
+ /**
+ * Create new {@link HttpServer} instance.
+ *
+ * @param uri uri on which the {@link ApplicationHandler} will be deployed. Only first path
+ * segment will be used as context path, the rest will be ignored.
+ * @param handler {@link HttpHandler} instance.
+ * @param secure used for call {@link NetworkListener#setSecure(boolean)}.
+ * @param sslEngineConfigurator Ssl settings to be passed to {@link NetworkListener#setSSLEngineConfig}.
+ * @param start if set to false, server will not get started, this allows end users to set
+ * additional properties on the underlying listener.
+ * @return newly created {@code HttpServer}.
+ * @throws ProcessingException in case of any failure when creating a new {@code HttpServer} instance.
+ * @see GrizzlyHttpContainer
+ */
+ public static HttpServer createHttpServer(final URI uri,
+ final GrizzlyHttpContainer handler,
+ final boolean secure,
+ final SSLEngineConfigurator sslEngineConfigurator,
+ final boolean start) {
+
+ final String host = (uri.getHost() == null) ? NetworkListener.DEFAULT_NETWORK_HOST : uri.getHost();
+ final int port = (uri.getPort() == -1)
+ ? (secure ? Container.DEFAULT_HTTPS_PORT : Container.DEFAULT_HTTP_PORT)
+ : uri.getPort();
+
+ final NetworkListener listener = new NetworkListener("grizzly", host, port);
+
+ listener.getTransport().getWorkerThreadPoolConfig().setThreadFactory(new ThreadFactoryBuilder()
+ .setNameFormat("grizzly-http-server-%d")
+ .setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler())
+ .build());
+
+ listener.setSecure(secure);
+ if (sslEngineConfigurator != null) {
+ listener.setSSLEngineConfig(sslEngineConfigurator);
+ }
+
+ final HttpServer server = new HttpServer();
+ server.addListener(listener);
+
+ // Map the path to the processor.
+ final ServerConfiguration config = server.getServerConfiguration();
+ if (handler != null) {
+ final String path = uri.getPath().replaceAll("/{2,}", "/");
+
+ final String contextPath = path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
+ config.addHttpHandler(handler, HttpHandlerRegistration.bulder().contextPath(contextPath).build());
+ }
+
+ config.setPassTraceRequest(true);
+ config.setDefaultQueryEncoding(Charsets.UTF8_CHARSET);
+
+ if (start) {
+ try {
+ // Start the server.
+ server.start();
+ } catch (final IOException ex) {
+ server.shutdownNow();
+ throw new ProcessingException(LocalizationMessages.FAILED_TO_START_SERVER(ex.getMessage()), ex);
+ }
+ }
+
+ return server;
+ }
+
+ /**
+ * Prevents instantiation.
+ */
+ private GrizzlyHttpServerFactory() {
+ }
+}
diff --git a/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyRequestPropertiesDelegate.java b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyRequestPropertiesDelegate.java
new file mode 100644
index 0000000..d14917f
--- /dev/null
+++ b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/GrizzlyRequestPropertiesDelegate.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.grizzly2.httpserver;
+
+import java.util.Collection;
+
+import org.glassfish.jersey.internal.PropertiesDelegate;
+
+import org.glassfish.grizzly.http.server.Request;
+
+/**
+ * Grizzly container {@link PropertiesDelegate properties delegate}.
+ *
+ * @author Martin Matula
+ */
+class GrizzlyRequestPropertiesDelegate implements PropertiesDelegate {
+ private final Request request;
+
+ /**
+ * Create new Grizzly container properties delegate instance.
+ *
+ * @param request grizzly HTTP request.
+ */
+ GrizzlyRequestPropertiesDelegate(Request request) {
+ this.request = request;
+ }
+
+ @Override
+ public Object getProperty(String name) {
+ return request.getAttribute(name);
+ }
+
+ @Override
+ public Collection<String> getPropertyNames() {
+ return request.getAttributeNames();
+ }
+
+ @Override
+ public void setProperty(String name, Object value) {
+ request.setAttribute(name, value);
+ }
+
+ @Override
+ public void removeProperty(String name) {
+ request.removeAttribute(name);
+ }
+}
diff --git a/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/package-info.java b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/package-info.java
new file mode 100644
index 0000000..75cf389
--- /dev/null
+++ b/containers/grizzly2-http/src/main/java/org/glassfish/jersey/grizzly2/httpserver/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey Grizzly 2.x container classes.
+ */
+package org.glassfish.jersey.grizzly2.httpserver;
diff --git a/containers/grizzly2-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider b/containers/grizzly2-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
new file mode 100644
index 0000000..57f405d
--- /dev/null
+++ b/containers/grizzly2-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpContainerProvider
\ No newline at end of file
diff --git a/containers/grizzly2-http/src/main/resources/org/glassfish/jersey/grizzly2/httpserver/internal/localization.properties b/containers/grizzly2-http/src/main/resources/org/glassfish/jersey/grizzly2/httpserver/internal/localization.properties
new file mode 100644
index 0000000..83ce439
--- /dev/null
+++ b/containers/grizzly2-http/src/main/resources/org/glassfish/jersey/grizzly2/httpserver/internal/localization.properties
@@ -0,0 +1,20 @@
+#
+# Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+# {0} - status code; {1} - status reason message
+exception.sending.error.response=I/O exception occurred while sending "{0}/{1}" error response.
+# {0} - exception message
+failed.to.start.server=Failed to start Grizzly HTTP server: {0}
diff --git a/containers/grizzly2-servlet/pom.xml b/containers/grizzly2-servlet/pom.xml
new file mode 100644
index 0000000..caee668
--- /dev/null
+++ b/containers/grizzly2-servlet/pom.xml
@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-grizzly2-servlet</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-grizzly2-servlet</name>
+
+ <description>Grizzly 2 Servlet Container.</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>javax.servlet</groupId>
+ <artifactId>javax.servlet-api</artifactId>
+ <version>${servlet4.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>jersey-container-servlet</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>jersey-container-grizzly2-http</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.grizzly</groupId>
+ <artifactId>grizzly-http-servlet</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Import-Package>
+ javax.servlet.*;version="[2.4,5.0)",
+ *
+ </Import-Package>
+ </instructions>
+ <unpackBundle>true</unpackBundle>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/GrizzlyWebContainerFactory.java b/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/GrizzlyWebContainerFactory.java
new file mode 100644
index 0000000..db969dd
--- /dev/null
+++ b/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/GrizzlyWebContainerFactory.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.grizzly2.servlet;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Map;
+
+import javax.servlet.Servlet;
+
+import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
+import org.glassfish.jersey.servlet.ServletContainer;
+import org.glassfish.jersey.uri.UriComponent;
+
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.glassfish.grizzly.servlet.ServletRegistration;
+import org.glassfish.grizzly.servlet.WebappContext;
+
+/**
+ * Factory for creating and starting Grizzly 2 {@link HttpServer} instances
+ * for deploying a {@code Servlet}.
+ * <p/>
+ * The default deployed server is an instance of {@link ServletContainer}.
+ * <p/>
+ * If no initialization parameters are declared (or is null) then root
+ * resource and provider classes will be found by searching the classes
+ * referenced in the java classpath.
+ *
+ * @author Paul Sandoz
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+public final class GrizzlyWebContainerFactory {
+
+ private GrizzlyWebContainerFactory() {
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws java.io.IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(String u)
+ throws IOException, IllegalArgumentException {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u));
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(String u, Map<String, String> initParams)
+ throws IOException, IllegalArgumentException {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), initParams);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(URI u)
+ throws IOException, IllegalArgumentException {
+ return create(u, ServletContainer.class);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(URI u,
+ Map<String, String> initParams) throws IOException {
+ return create(u, ServletContainer.class, initParams);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(String u, Class<? extends Servlet> c) throws IOException {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), c);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(String u, Class<? extends Servlet> c,
+ Map<String, String> initParams) throws IOException {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), c, initParams);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(URI u, Class<? extends Servlet> c) throws IOException {
+ return create(u, c, null);
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(URI u, Class<? extends Servlet> c,
+ Map<String, String> initParams) throws IOException {
+ return create(u, c, null, initParams, null);
+ }
+
+ private static HttpServer create(URI u, Class<? extends Servlet> c, Servlet servlet,
+ Map<String, String> initParams, Map<String, String> contextInitParams)
+ throws IOException {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ String path = u.getPath();
+ if (path == null) {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ", must be non-null");
+ } else if (path.isEmpty()) {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ", must be present");
+ } else if (path.charAt(0) != '/') {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ". must start with a '/'");
+ }
+
+ path = String.format("/%s", UriComponent.decodePath(u.getPath(), true).get(1).toString());
+
+ WebappContext context = new WebappContext("GrizzlyContext", path);
+ ServletRegistration registration;
+ if (c != null) {
+ registration = context.addServlet(c.getName(), c);
+ } else {
+ registration = context.addServlet(servlet.getClass().getName(), servlet);
+ }
+ registration.addMapping("/*");
+
+ if (contextInitParams != null) {
+ for (Map.Entry<String, String> e : contextInitParams.entrySet()) {
+ context.setInitParameter(e.getKey(), e.getValue());
+ }
+ }
+
+ if (initParams != null) {
+ registration.setInitParameters(initParams);
+ }
+
+ HttpServer server = GrizzlyHttpServerFactory.createHttpServer(u);
+ context.deploy(server);
+ return server;
+ }
+
+ /**
+ * Create a {@link HttpServer} that registers the declared servlet instance.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param servlet the servlet instance.
+ * @param initParams the servlet initialization parameters.
+ * @param contextInitParams the servlet context initialization parameters.
+ * @return the http server, with the endpoint started.
+ *
+ * @throws IOException if an error occurs creating the container.
+ * @throws IllegalArgumentException if {@code u} is {@code null}.
+ */
+ public static HttpServer create(URI u, Servlet servlet, Map<String, String> initParams, Map<String, String> contextInitParams)
+ throws IOException {
+ if (servlet == null) {
+ throw new IllegalArgumentException("The servlet must not be null");
+ }
+ return create(u, null, servlet, initParams, contextInitParams);
+ }
+}
diff --git a/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/package-info.java b/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/package-info.java
new file mode 100644
index 0000000..41a7e50
--- /dev/null
+++ b/containers/grizzly2-servlet/src/main/java/org/glassfish/jersey/grizzly2/servlet/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey Grizzly 2.x Servlet container classes.
+ */
+package org.glassfish.jersey.grizzly2.servlet;
diff --git a/containers/jdk-http/pom.xml b/containers/jdk-http/pom.xml
new file mode 100644
index 0000000..41c87bd
--- /dev/null
+++ b/containers/jdk-http/pom.xml
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-jdk-http</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-jdk-http</name>
+
+ <description>JDK Http Container</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ </plugin>
+ </plugins>
+
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ </build>
+
+ <profiles>
+ <profile>
+ <id>windows</id>
+ <activation>
+ <os>
+ <family>windows</family>
+ </os>
+ </activation>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <!-- Exclude unit tests regarding JDK HTTP Server because of failing a server shutdown in a class
+ with several tests. "java.net.BindException: Address already in use: bind"
+ bug reported on https://bugs.openjdk.java.net/browse/JDK-8015692 -->
+ <excludes>
+ <exclude>org/glassfish/jersey/jdkhttp/BasicJdkHttpServerTest.java</exclude>
+ <exclude>org/glassfish/jersey/jdkhttp/JdkHttpPackageTest.java</exclude>
+ <exclude>org/glassfish/jersey/jdkhttp/JdkHttpsServerTest.java</exclude>
+ <exclude>org/glassfish/jersey/jdkhttp/LifecycleListenerTest.java</exclude>
+ </excludes>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
+
+</project>
diff --git a/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainer.java b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainer.java
new file mode 100644
index 0000000..051c5ca
--- /dev/null
+++ b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainer.java
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.Principal;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.SecurityContext;
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.internal.MapPropertiesDelegate;
+import org.glassfish.jersey.jdkhttp.internal.LocalizationMessages;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.HttpsExchange;
+
+/**
+ * Jersey {@code Container} implementation based on Java SE {@link HttpServer}.
+ *
+ * @author Miroslav Fuksa
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class JdkHttpHandlerContainer implements HttpHandler, Container {
+
+ private static final Logger LOGGER = Logger.getLogger(JdkHttpHandlerContainer.class.getName());
+
+ private volatile ApplicationHandler appHandler;
+
+ /**
+ * Create new lightweight Java SE HTTP server container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on the container.
+ */
+ JdkHttpHandlerContainer(final Application application) {
+ this.appHandler = new ApplicationHandler(application);
+ }
+
+ /**
+ * Create new lightweight Java SE HTTP server container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on the container.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ */
+ JdkHttpHandlerContainer(final Application application, final Object parentContext) {
+ this.appHandler = new ApplicationHandler(application, null, parentContext);
+ }
+
+ @Override
+ public void handle(final HttpExchange exchange) throws IOException {
+ /**
+ * This is a URI that contains the path, query and fragment components.
+ */
+ URI exchangeUri = exchange.getRequestURI();
+
+ /**
+ * The base path specified by the HTTP context of the HTTP handler. It
+ * is in decoded form.
+ */
+ String decodedBasePath = exchange.getHttpContext().getPath();
+
+ // Ensure that the base path ends with a '/'
+ if (!decodedBasePath.endsWith("/")) {
+ if (decodedBasePath.equals(exchangeUri.getPath())) {
+ /**
+ * This is an edge case where the request path does not end in a
+ * '/' and is equal to the context path of the HTTP handler.
+ * Both the request path and base path need to end in a '/'
+ * Currently the request path is modified.
+ *
+ * TODO support redirection in accordance with resource configuration feature.
+ */
+ exchangeUri = UriBuilder.fromUri(exchangeUri)
+ .path("/").build();
+ }
+ decodedBasePath += "/";
+ }
+
+ /*
+ * The following is madness, there is no easy way to get the complete
+ * URI of the HTTP request!!
+ *
+ * TODO this is missing the user information component, how can this be obtained?
+ */
+ final boolean isSecure = exchange instanceof HttpsExchange;
+ final String scheme = isSecure ? "https" : "http";
+
+ final URI baseUri = getBaseUri(exchange, decodedBasePath, scheme);
+ final URI requestUri = getRequestUri(exchange, baseUri);
+
+ final ResponseWriter responseWriter = new ResponseWriter(exchange);
+ final ContainerRequest requestContext = new ContainerRequest(baseUri, requestUri,
+ exchange.getRequestMethod(), getSecurityContext(exchange.getPrincipal(), isSecure),
+ new MapPropertiesDelegate());
+ requestContext.setEntityStream(exchange.getRequestBody());
+ requestContext.getHeaders().putAll(exchange.getRequestHeaders());
+ requestContext.setWriter(responseWriter);
+ try {
+ appHandler.handle(requestContext);
+ } finally {
+ // if the response was not committed yet by the JerseyApplication
+ // then commit it and log warning
+ responseWriter.closeAndLogWarning();
+ }
+ }
+
+ private URI getBaseUri(final HttpExchange exchange, final String decodedBasePath, final String scheme) {
+ final URI baseUri;
+ try {
+ final List<String> hostHeader = exchange.getRequestHeaders().get("Host");
+ if (hostHeader != null) {
+ baseUri = new URI(scheme + "://" + hostHeader.get(0) + decodedBasePath);
+ } else {
+ final InetSocketAddress addr = exchange.getLocalAddress();
+ baseUri = new URI(scheme, null, addr.getHostName(), addr.getPort(),
+ decodedBasePath, null, null);
+ }
+ } catch (final URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ return baseUri;
+ }
+
+ private URI getRequestUri(final HttpExchange exchange, final URI baseUri) {
+ try {
+ return new URI(getServerAddress(baseUri) + exchange.getRequestURI());
+ } catch (URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getServerAddress(final URI baseUri) throws URISyntaxException {
+ return new URI(baseUri.getScheme(), null, baseUri.getHost(), baseUri.getPort(), null, null, null).toString();
+ }
+
+ private SecurityContext getSecurityContext(final Principal principal, final boolean isSecure) {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return false;
+ }
+
+ @Override
+ public boolean isSecure() {
+ return isSecure;
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return principal;
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return null;
+ }
+ };
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return appHandler.getConfiguration();
+ }
+
+ @Override
+ public void reload() {
+ reload(getConfiguration());
+ }
+
+ @Override
+ public void reload(final ResourceConfig configuration) {
+ appHandler.onShutdown(this);
+
+ appHandler = new ApplicationHandler(configuration);
+ appHandler.onReload(this);
+ appHandler.onStartup(this);
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return appHandler;
+ }
+
+ /**
+ * Inform this container that the server has been started.
+ *
+ * This method must be implicitly called after the server containing this container is started.
+ */
+ void onServerStart() {
+ this.appHandler.onStartup(this);
+ }
+
+ /**
+ * Inform this container that the server is being stopped.
+ *
+ * This method must be implicitly called before the server containing this container is stopped.
+ */
+ void onServerStop() {
+ this.appHandler.onShutdown(this);
+ }
+
+ private static final class ResponseWriter implements ContainerResponseWriter {
+
+ private final HttpExchange exchange;
+ private final AtomicBoolean closed;
+
+ /**
+ * Creates a new ResponseWriter for given {@link HttpExchange HTTP Exchange}.
+ *
+ * @param exchange Exchange of the {@link HttpServer JDK Http Server}
+ */
+ ResponseWriter(final HttpExchange exchange) {
+ this.exchange = exchange;
+ this.closed = new AtomicBoolean(false);
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(final long contentLength, final ContainerResponse context)
+ throws ContainerException {
+ final MultivaluedMap<String, String> responseHeaders = context.getStringHeaders();
+ final Headers serverHeaders = exchange.getResponseHeaders();
+ for (final Map.Entry<String, List<String>> e : responseHeaders.entrySet()) {
+ for (final String value : e.getValue()) {
+ serverHeaders.add(e.getKey(), value);
+ }
+ }
+
+ try {
+ if (context.getStatus() == Response.Status.NO_CONTENT.getStatusCode()) {
+ // Work around bug in LW HTTP server
+ // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6886436
+ exchange.sendResponseHeaders(context.getStatus(), -1);
+ } else {
+ exchange.sendResponseHeaders(context.getStatus(),
+ getResponseLength(contentLength));
+ }
+ } catch (final IOException ioe) {
+ throw new ContainerException(LocalizationMessages.ERROR_RESPONSEWRITER_WRITING_HEADERS(), ioe);
+ }
+
+ return exchange.getResponseBody();
+ }
+
+ private long getResponseLength(final long contentLength) {
+ if (contentLength == 0) {
+ return -1;
+ }
+ if (contentLength < 0) {
+ return 0;
+ }
+ return contentLength;
+ }
+
+ @Override
+ public boolean suspend(final long timeOut, final TimeUnit timeUnit, final TimeoutHandler timeoutHandler) {
+ throw new UnsupportedOperationException("Method suspend is not supported by the container.");
+ }
+
+ @Override
+ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit) throws IllegalStateException {
+ throw new UnsupportedOperationException("Method setSuspendTimeout is not supported by the container.");
+ }
+
+ @Override
+ public void failure(final Throwable error) {
+ try {
+ exchange.sendResponseHeaders(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), getResponseLength(0));
+ } catch (final IOException e) {
+ LOGGER.log(Level.WARNING, LocalizationMessages.ERROR_RESPONSEWRITER_SENDING_FAILURE_RESPONSE(), e);
+ } finally {
+ commit();
+ rethrow(error);
+ }
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return true;
+ }
+
+ @Override
+ public void commit() {
+ if (closed.compareAndSet(false, true)) {
+ exchange.close();
+ }
+ }
+
+ /**
+ * Rethrow the original exception as required by JAX-RS, 3.3.4
+ *
+ * @param error throwable to be re-thrown
+ */
+ private void rethrow(final Throwable error) {
+ if (error instanceof RuntimeException) {
+ throw (RuntimeException) error;
+ } else {
+ throw new ContainerException(error);
+ }
+ }
+
+ /**
+ * Commits the response and logs a warning message.
+ *
+ * This method should be called by the container at the end of the
+ * handle method to make sure that the ResponseWriter was committed.
+ */
+ private void closeAndLogWarning() {
+ if (closed.compareAndSet(false, true)) {
+ exchange.close();
+ LOGGER.log(Level.WARNING, LocalizationMessages.ERROR_RESPONSEWRITER_RESPONSE_UNCOMMITED());
+ }
+ }
+ }
+}
diff --git a/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainerProvider.java b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainerProvider.java
new file mode 100644
index 0000000..cd6306d
--- /dev/null
+++ b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpHandlerContainerProvider.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Application;
+
+import org.glassfish.jersey.server.spi.ContainerProvider;
+
+import com.sun.net.httpserver.HttpHandler;
+
+/**
+ * Container provider for containers based on lightweight Java SE HTTP Server's {@link HttpHandler}.
+ *
+ * @author Miroslav Fuksa
+ */
+public final class JdkHttpHandlerContainerProvider implements ContainerProvider {
+
+ @Override
+ public <T> T createContainer(Class<T> type, Application application) throws ProcessingException {
+ if (type != HttpHandler.class && type != JdkHttpHandlerContainer.class) {
+ return null;
+ }
+ return type.cast(new JdkHttpHandlerContainer(application));
+ }
+}
diff --git a/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpServerFactory.java b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpServerFactory.java
new file mode 100644
index 0000000..0f1fbb2
--- /dev/null
+++ b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/JdkHttpServerFactory.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.logging.Logger;
+
+import javax.ws.rs.ProcessingException;
+
+import javax.net.ssl.SSLContext;
+
+import org.glassfish.jersey.internal.guava.ThreadFactoryBuilder;
+import org.glassfish.jersey.jdkhttp.internal.LocalizationMessages;
+import org.glassfish.jersey.process.JerseyProcessingUncaughtExceptionHandler;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.Container;
+
+import com.sun.net.httpserver.HttpContext;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.HttpsConfigurator;
+import com.sun.net.httpserver.HttpsServer;
+
+/**
+ * Factory for creating {@link HttpServer JDK HttpServer} instances to run Jersey applications.
+ *
+ * @author Miroslav Fuksa
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class JdkHttpServerFactory {
+
+ private static final Logger LOG = Logger.getLogger(JdkHttpServerFactory.class.getName());
+
+ /**
+ * Create and start the {@link HttpServer JDK HttpServer} with the Jersey application deployed
+ * at the given {@link URI}.
+ * <p>
+ * The returned {@link HttpServer JDK HttpServer} is started.
+ * </p>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation
+ * occurs.
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration) {
+ return createHttpServer(uri, configuration, true);
+ }
+
+ /**
+ * Create (and possibly start) the {@link HttpServer JDK HttpServer} with the JAX-RS / Jersey application deployed
+ * on the given {@link URI}.
+ * <p>
+ * The {@code start} flag controls whether or not the returned {@link HttpServer JDK HttpServer} is started.
+ * </p>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @param start if set to {@code false}, the created server will not be automatically started.
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation occurs.
+ * @since 2.8
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration, final boolean start) {
+ return createHttpServer(uri, new JdkHttpHandlerContainer(configuration), start);
+ }
+
+ /**
+ * Create (and possibly start) the {@link HttpServer JDK HttpServer} with the JAX-RS / Jersey application deployed
+ * on the given {@link URI}.
+ * <p/>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation occurs.
+ * @see org.glassfish.jersey.jdkhttp.JdkHttpHandlerContainer
+ * @since 2.12
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration,
+ final Object parentContext) {
+ return createHttpServer(uri, new JdkHttpHandlerContainer(configuration, parentContext), true);
+ }
+
+ /**
+ * Create and start the {@link HttpServer JDK HttpServer}, eventually {@code HttpServer}'s subclass
+ * {@link HttpsServer JDK HttpsServer} with the JAX-RS / Jersey application deployed on the given {@link URI}.
+ * <p>
+ * The returned {@link HttpServer JDK HttpServer} is started.
+ * </p>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @param sslContext custom {@link SSLContext} to be passed to the server
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation occurs.
+ * @since 2.18
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration,
+ final SSLContext sslContext) {
+ return createHttpServer(uri, new JdkHttpHandlerContainer(configuration),
+ sslContext, true);
+ }
+
+ /**
+ * Create (and possibly start) the {@link HttpServer JDK HttpServer}, eventually {@code HttpServer}'s subclass
+ * {@link HttpsServer JDK HttpsServer} with the JAX-RS / Jersey application deployed on the given {@link URI}.
+ * <p>
+ * The {@code start} flag controls whether or not the returned {@link HttpServer JDK HttpServer} is started.
+ * </p>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @param sslContext custom {@link SSLContext} to be passed to the server
+ * @param start if set to {@code false}, the created server will not be automatically started.
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation occurs.
+ * @since 2.17
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration,
+ final SSLContext sslContext, final boolean start) {
+ return createHttpServer(uri,
+ new JdkHttpHandlerContainer(configuration),
+ sslContext,
+ start);
+ }
+
+ /**
+ * Create (and possibly start) the {@link HttpServer JDK HttpServer}, eventually {@code HttpServer}'s subclass
+ * {@link HttpsServer} with the JAX-RS / Jersey application deployed on the given {@link URI}.
+ * <p>
+ * The {@code start} flag controls whether or not the returned {@link HttpServer JDK HttpServer} is started.
+ * </p>
+ *
+ * @param uri the {@link URI uri} on which the Jersey application will be deployed.
+ * @param configuration the Jersey server-side application configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @param sslContext custom {@link SSLContext} to be passed to the server
+ * @param start if set to {@code false}, the created server will not be automatically started.
+ * @return Newly created {@link HttpServer}.
+ * @throws ProcessingException thrown when problems during server creation occurs.
+ * @since 2.18
+ */
+ public static HttpServer createHttpServer(final URI uri, final ResourceConfig configuration,
+ final Object parentContext,
+ final SSLContext sslContext, final boolean start) {
+ return createHttpServer(uri,
+ new JdkHttpHandlerContainer(configuration, parentContext),
+ sslContext,
+ start
+ );
+ }
+
+ private static HttpServer createHttpServer(final URI uri, final JdkHttpHandlerContainer handler,
+ final boolean start) {
+ return createHttpServer(uri, handler, null, start);
+ }
+
+ private static HttpServer createHttpServer(final URI uri,
+ final JdkHttpHandlerContainer handler,
+ final SSLContext sslContext,
+ final boolean start) {
+ if (uri == null) {
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_URI_NULL());
+ }
+
+ final String scheme = uri.getScheme();
+ final boolean isHttp = "http".equalsIgnoreCase(scheme);
+ final boolean isHttps = "https".equalsIgnoreCase(scheme);
+ final HttpsConfigurator httpsConfigurator = sslContext != null ? new HttpsConfigurator(sslContext) : null;
+
+ if (isHttp) {
+ if (httpsConfigurator != null) {
+ // attempt to use https with http scheme
+ LOG.warning(LocalizationMessages.WARNING_CONTAINER_URI_SCHEME_SECURED());
+ }
+ } else if (isHttps) {
+ if (httpsConfigurator == null) {
+ if (start) {
+ // The SSLContext (via HttpsConfigurator) has to be set before the server starts.
+ // Starting https server w/o SSL is invalid, it will lead to error anyway.
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_HTTPS_NO_SSL());
+ } else {
+ // Creating the https server w/o SSL context, but not starting it is valid.
+ // However, server.setHttpsConfigurator() must be called before the start.
+ LOG.info(LocalizationMessages.INFO_CONTAINER_HTTPS_NO_SSL());
+ }
+ }
+ } else {
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_URI_SCHEME_UNKNOWN(uri));
+ }
+
+ final String path = uri.getPath();
+ if (path == null) {
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_URI_PATH_NULL(uri));
+ } else if (path.isEmpty()) {
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_URI_PATH_EMPTY(uri));
+ } else if (path.charAt(0) != '/') {
+ throw new IllegalArgumentException(LocalizationMessages.ERROR_CONTAINER_URI_PATH_START(uri));
+ }
+
+ final int port = (uri.getPort() == -1)
+ ? (isHttp ? Container.DEFAULT_HTTP_PORT : Container.DEFAULT_HTTPS_PORT)
+ : uri.getPort();
+
+ final HttpServer server;
+ try {
+ server = isHttp
+ ? HttpServer.create(new InetSocketAddress(port), 0)
+ : HttpsServer.create(new InetSocketAddress(port), 0);
+ } catch (final IOException ioe) {
+ throw new ProcessingException(LocalizationMessages.ERROR_CONTAINER_EXCEPTION_IO(), ioe);
+ }
+
+ if (isHttps && httpsConfigurator != null) {
+ ((HttpsServer) server).setHttpsConfigurator(httpsConfigurator);
+ }
+
+ server.setExecutor(Executors.newCachedThreadPool(new ThreadFactoryBuilder()
+ .setNameFormat("jdk-http-server-%d")
+ .setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler())
+ .build()));
+ server.createContext(path, handler);
+
+ final HttpServer wrapper = isHttp
+ ? createHttpServerWrapper(server, handler)
+ : createHttpsServerWrapper((HttpsServer) server, handler);
+
+ if (start) {
+ wrapper.start();
+ }
+
+ return wrapper;
+ }
+
+ private static HttpServer createHttpsServerWrapper(final HttpsServer delegate, final JdkHttpHandlerContainer handler) {
+ return new HttpsServer() {
+
+ @Override
+ public void setHttpsConfigurator(final HttpsConfigurator httpsConfigurator) {
+ delegate.setHttpsConfigurator(httpsConfigurator);
+ }
+
+ @Override
+ public HttpsConfigurator getHttpsConfigurator() {
+ return delegate.getHttpsConfigurator();
+ }
+
+ @Override
+ public void bind(final InetSocketAddress inetSocketAddress, final int i) throws IOException {
+ delegate.bind(inetSocketAddress, i);
+ }
+
+ @Override
+ public void start() {
+ delegate.start();
+ handler.onServerStart();
+ }
+
+ @Override
+ public void setExecutor(final Executor executor) {
+ delegate.setExecutor(executor);
+ }
+
+ @Override
+ public Executor getExecutor() {
+ return delegate.getExecutor();
+ }
+
+ @Override
+ public void stop(final int i) {
+ handler.onServerStop();
+ delegate.stop(i);
+ }
+
+ @Override
+ public HttpContext createContext(final String s, final HttpHandler httpHandler) {
+ return delegate.createContext(s, httpHandler);
+ }
+
+ @Override
+ public HttpContext createContext(final String s) {
+ return delegate.createContext(s);
+ }
+
+ @Override
+ public void removeContext(final String s) throws IllegalArgumentException {
+ delegate.removeContext(s);
+ }
+
+ @Override
+ public void removeContext(final HttpContext httpContext) {
+ delegate.removeContext(httpContext);
+ }
+
+ @Override
+ public InetSocketAddress getAddress() {
+ return delegate.getAddress();
+ }
+ };
+ }
+
+ private static HttpServer createHttpServerWrapper(final HttpServer delegate, final JdkHttpHandlerContainer handler) {
+ return new HttpServer() {
+
+ @Override
+ public void bind(final InetSocketAddress inetSocketAddress, final int i) throws IOException {
+ delegate.bind(inetSocketAddress, i);
+ }
+
+ @Override
+ public void start() {
+ delegate.start();
+ handler.onServerStart();
+ }
+
+ @Override
+ public void setExecutor(final Executor executor) {
+ delegate.setExecutor(executor);
+ }
+
+ @Override
+ public Executor getExecutor() {
+ return delegate.getExecutor();
+ }
+
+ @Override
+ public void stop(final int i) {
+ handler.onServerStop();
+ delegate.stop(i);
+ }
+
+ @Override
+ public HttpContext createContext(final String s, final HttpHandler httpHandler) {
+ return delegate.createContext(s, httpHandler);
+ }
+
+ @Override
+ public HttpContext createContext(final String s) {
+ return delegate.createContext(s);
+ }
+
+ @Override
+ public void removeContext(final String s) throws IllegalArgumentException {
+ delegate.removeContext(s);
+ }
+
+ @Override
+ public void removeContext(final HttpContext httpContext) {
+ delegate.removeContext(httpContext);
+ }
+
+ @Override
+ public InetSocketAddress getAddress() {
+ return delegate.getAddress();
+ }
+ };
+ }
+
+ /**
+ * Prevents instantiation.
+ */
+ private JdkHttpServerFactory() {
+ throw new AssertionError("Instantiation not allowed.");
+ }
+}
diff --git a/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/package-info.java b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/package-info.java
new file mode 100644
index 0000000..c60ec6e
--- /dev/null
+++ b/containers/jdk-http/src/main/java/org/glassfish/jersey/jdkhttp/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * The container adapter between {@link com.sun.net.httpserver.HttpServer JDK HTTP server}
+ * and Jersey {@link org.glassfish.jersey.server.ApplicationHandler Jersey application handler}
+ * classes.
+ */
+package org.glassfish.jersey.jdkhttp;
diff --git a/containers/jdk-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider b/containers/jdk-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
new file mode 100644
index 0000000..efdf94e
--- /dev/null
+++ b/containers/jdk-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.jdkhttp.JdkHttpHandlerContainerProvider
\ No newline at end of file
diff --git a/containers/jdk-http/src/main/resources/org/glassfish/jersey/jdkhttp/internal/localization.properties b/containers/jdk-http/src/main/resources/org/glassfish/jersey/jdkhttp/internal/localization.properties
new file mode 100644
index 0000000..745c494
--- /dev/null
+++ b/containers/jdk-http/src/main/resources/org/glassfish/jersey/jdkhttp/internal/localization.properties
@@ -0,0 +1,30 @@
+#
+# Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+error.container.exception.io=IOException thrown when creating the JDK HttpServer.
+error.container.uri.null=The URI must not be null.
+error.container.uri.path.empty=The URI path, of the URI {0} must be present (not an empty string).
+error.container.uri.path.null=The URI path, of the URI {0} must be non-null.
+error.container.uri.path.start=The URI path, of the URI {0} must start with a '/'.
+error.container.uri.scheme.unknown=The URI scheme, of the URI {0} must be equal (ignoring case) to 'http' or 'https'.
+error.container.https.no.ssl=Attempt to start a HTTPS server with no SSL context defined.
+error.responsewriter.response.uncommited=ResponseWriter was not commited yet. Committing the Response now.
+error.responsewriter.sending.failure.response=Unable to send a failure response.
+error.responsewriter.writing.headers=Error writing out the response headers.
+info.container.https.no.ssl=HTTPS server will be created with no SSL context defined. HttpsConfigurator must be \
+ set before the server is started.
+warning.container.uri.scheme.secured=SSLContext is set, but http scheme was used instead of https. The SSLContext will \
+ be ignored.
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/AbstractJdkHttpServerTester.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/AbstractJdkHttpServerTester.java
new file mode 100644
index 0000000..24998f9
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/AbstractJdkHttpServerTester.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import java.net.URI;
+import java.security.AccessController;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.UriBuilder;
+
+import com.sun.net.httpserver.HttpServer;
+import org.glassfish.jersey.internal.util.PropertiesHelper;
+import org.glassfish.jersey.logging.LoggingFeature;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.junit.After;
+
+/**
+ * Abstract JDK HTTP Server unit tester.
+ *
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public abstract class AbstractJdkHttpServerTester {
+
+ public static final String CONTEXT = "";
+ private final int DEFAULT_PORT = 9998;
+
+ private static final Logger LOGGER = Logger.getLogger(AbstractJdkHttpServerTester.class.getName());
+
+ /**
+ * Get the port to be used for test application deployments.
+ *
+ * @return The HTTP port of the URI
+ */
+ protected final int getPort() {
+ final String value =
+ AccessController.doPrivileged(PropertiesHelper.getSystemProperty("jersey.config.test.container.port"));
+ if (value != null) {
+
+ try {
+ final int i = Integer.parseInt(value);
+ if (i <= 0) {
+ throw new NumberFormatException("Value not positive.");
+ }
+ return i;
+ } catch (NumberFormatException e) {
+ LOGGER.log(Level.CONFIG,
+ "Value of 'jersey.config.test.container.port'"
+ + " property is not a valid positive integer [" + value + "]."
+ + " Reverting to default [" + DEFAULT_PORT + "].",
+ e);
+ }
+ }
+ return DEFAULT_PORT;
+ }
+
+ private volatile HttpServer server;
+
+ public UriBuilder getUri() {
+ return UriBuilder.fromUri("http://localhost").port(getPort()).path(CONTEXT);
+ }
+
+ public void startServer(Class... resources) {
+ ResourceConfig config = new ResourceConfig(resources);
+ config.register(LoggingFeature.class);
+ final URI baseUri = getBaseUri();
+ server = JdkHttpServerFactory.createHttpServer(baseUri, config);
+ LOGGER.log(Level.INFO, "jdk-http server started on base uri: " + baseUri);
+ }
+
+ public void startServer(ResourceConfig config) {
+ final URI baseUri = getBaseUri();
+ config.register(LoggingFeature.class);
+ server = JdkHttpServerFactory.createHttpServer(baseUri, config);
+ LOGGER.log(Level.INFO, "jdk-http server started on base uri: " + baseUri);
+ }
+
+ public URI getBaseUri() {
+ return UriBuilder.fromUri("http://localhost/").port(getPort()).build();
+ }
+
+ public void stopServer() {
+ try {
+ server.stop(3);
+ server = null;
+ LOGGER.log(Level.INFO, "Simple-http server stopped.");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @After
+ public void tearDown() {
+ if (server != null) {
+ stopServer();
+ }
+ }
+}
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/BasicJdkHttpServerTest.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/BasicJdkHttpServerTest.java
new file mode 100644
index 0000000..62a344d
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/BasicJdkHttpServerTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.junit.After;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.HttpsServer;
+
+/**
+ * Jdk Http Server basic tests.
+ *
+ * @author Michal Gajdos
+ */
+public class BasicJdkHttpServerTest extends AbstractJdkHttpServerTester {
+
+ private HttpServer server;
+
+ @Path("/test")
+ public static class TestResource {
+
+ @GET
+ public String get() {
+ return "test";
+ }
+ }
+
+ @Test
+ public void testCreateHttpServer() throws Exception {
+ server = JdkHttpServerFactory.createHttpServer(
+ UriBuilder.fromUri("http://localhost/").port(getPort()).build(), new ResourceConfig(TestResource.class));
+
+ assertThat(server, instanceOf(HttpServer.class));
+ assertThat(server, not(instanceOf(HttpsServer.class)));
+ }
+
+ @Test
+ public void testCreateHttpsServer() throws Exception {
+ server = JdkHttpServerFactory.createHttpServer(
+ UriBuilder.fromUri("https://localhost/").port(getPort()).build(),
+ new ResourceConfig(TestResource.class),
+ false);
+
+ assertThat(server, instanceOf(HttpsServer.class));
+ }
+
+ @After
+ public void tearDown() {
+ if (server != null) {
+ server.stop(3);
+ server = null;
+ }
+ }
+}
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpPackageTest.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpPackageTest.java
new file mode 100644
index 0000000..675bbaa
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpPackageTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Jdk Http Container package scanning test.
+ *
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class JdkHttpPackageTest extends AbstractJdkHttpServerTester {
+
+ @Path("/packageTest")
+ public static class TestResource {
+ @GET
+ public String get() {
+ return "test";
+ }
+
+ @GET
+ @Path("sub")
+ public String getSub() {
+ return "test-sub";
+ }
+ }
+
+ @Test
+ public void testJdkHttpPackage() {
+ final ResourceConfig rc = new ResourceConfig();
+ rc.packages(this.getClass().getPackage().getName());
+
+ startServer(rc);
+
+ WebTarget r = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ assertEquals("test", r.path("packageTest").request().get(String.class));
+ assertEquals("test-sub", r.path("packageTest/sub").request().get(String.class));
+ assertEquals(404, r.path("wrong").request().get(Response.class).getStatus());
+
+ }
+}
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpsServerTest.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpsServerTest.java
new file mode 100644
index 0000000..180f2bc
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/JdkHttpsServerTest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.UriBuilder;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLHandshakeException;
+
+import org.glassfish.jersey.SslConfigurator;
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.junit.After;
+import org.junit.Test;
+
+import com.google.common.io.ByteStreams;
+
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.HttpsConfigurator;
+import com.sun.net.httpserver.HttpsServer;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Jdk Https Server tests.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ */
+public class JdkHttpsServerTest extends AbstractJdkHttpServerTester {
+
+ private static final String TRUSTSTORE_CLIENT_FILE = "./truststore_client";
+ private static final String TRUSTSTORE_CLIENT_PWD = "asdfgh";
+ private static final String KEYSTORE_CLIENT_FILE = "./keystore_client";
+ private static final String KEYSTORE_CLIENT_PWD = "asdfgh";
+
+ private static final String KEYSTORE_SERVER_FILE = "./keystore_server";
+ private static final String KEYSTORE_SERVER_PWD = "asdfgh";
+ private static final String TRUSTSTORE_SERVER_FILE = "./truststore_server";
+ private static final String TRUSTSTORE_SERVER_PWD = "asdfgh";
+
+ private HttpServer server;
+ private final URI httpsUri = UriBuilder.fromUri("https://localhost/").port(getPort()).build();
+ private final URI httpUri = UriBuilder.fromUri("http://localhost/").port(getPort()).build();
+ private final ResourceConfig rc = new ResourceConfig(TestResource.class);
+
+ @Path("/testHttps")
+ public static class TestResource {
+ @GET
+ public String get() {
+ return "test";
+ }
+ }
+
+ /**
+ * Test, that {@link HttpsServer} instance is returned when providing empty SSLContext (but not starting).
+ * @throws Exception
+ */
+ @Test
+ public void testCreateHttpsServerNoSslContext() throws Exception {
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, null, false);
+ assertThat(server, instanceOf(HttpsServer.class));
+ }
+
+ /**
+ * Test, that exception is thrown when attempting to start a {@link HttpsServer} with empty SSLContext.
+ * @throws Exception
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testStartHttpServerNoSslContext() throws Exception {
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, null, true);
+ }
+
+ /**
+ * Test, that {@link javax.net.ssl.SSLHandshakeException} is thrown when attepmting to connect to server with client
+ * not configured correctly.
+ * @throws Exception
+ */
+ @Test(expected = SSLHandshakeException.class)
+ public void testCreateHttpsServerDefaultSslContext() throws Throwable {
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, SSLContext.getDefault(), true);
+ assertThat(server, instanceOf(HttpsServer.class));
+
+ // access the https server with not configured client
+ final Client client = ClientBuilder.newBuilder().newClient();
+ try {
+ client.target(httpsUri).path("testHttps").request().get(String.class);
+ } catch (final ProcessingException e) {
+ throw e.getCause();
+ }
+ }
+
+ /**
+ * Test, that {@link HttpsServer} can be manually started even with (empty) SSLContext, but will throw an exception
+ * on request.
+ * @throws Exception
+ */
+ @Test(expected = IOException.class)
+ public void testHttpsServerNoSslContextDelayedStart() throws Throwable {
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, null, false);
+ assertThat(server, instanceOf(HttpsServer.class));
+ server.start();
+
+ final Client client = ClientBuilder.newBuilder().newClient();
+ try {
+ client.target(httpsUri).path("testHttps").request().get(String.class);
+ } catch (final ProcessingException e) {
+ throw e.getCause();
+ }
+ }
+
+ /**
+ * Test, that {@link HttpsServer} cannot be configured with {@link HttpsConfigurator} after it has started.
+ * @throws Exception
+ */
+ @Test(expected = IllegalStateException.class)
+ public void testConfigureSslContextAfterStart() throws Throwable {
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, null, false);
+ assertThat(server, instanceOf(HttpsServer.class));
+ server.start();
+ ((HttpsServer) server).setHttpsConfigurator(new HttpsConfigurator(getServerSslContext()));
+ }
+
+ /**
+ * Tests a client to server roundtrip with correctly configured SSL on both sides.
+ * @throws IOException
+ */
+ @Test
+ public void testCreateHttpsServerRoundTrip() throws IOException {
+ final SSLContext serverSslContext = getServerSslContext();
+
+ server = JdkHttpServerFactory.createHttpServer(httpsUri, rc, serverSslContext, true);
+
+ final SSLContext foundContext = ((HttpsServer) server).getHttpsConfigurator().getSSLContext();
+ assertEquals(serverSslContext, foundContext);
+
+ final SSLContext clientSslContext = getClientSslContext();
+ final Client client = ClientBuilder.newBuilder().sslContext(clientSslContext).build();
+ final String response = client.target(httpsUri).path("testHttps").request().get(String.class);
+
+ assertEquals("test", response);
+ }
+
+ /**
+ * Test, that if URI uses http scheme instead of https, SSLContext is ignored.
+ * @throws IOException
+ */
+ @Test
+ public void testHttpWithSsl() throws IOException {
+ server = JdkHttpServerFactory.createHttpServer(httpUri, rc, getServerSslContext(), true);
+ assertThat(server, instanceOf(HttpServer.class));
+ assertThat(server, not(instanceOf(HttpsServer.class)));
+ }
+
+ private SSLContext getClientSslContext() throws IOException {
+ final InputStream trustStore = JdkHttpsServerTest.class.getResourceAsStream(TRUSTSTORE_CLIENT_FILE);
+ final InputStream keyStore = JdkHttpsServerTest.class.getResourceAsStream(KEYSTORE_CLIENT_FILE);
+
+
+ final SslConfigurator sslConfigClient = SslConfigurator.newInstance()
+ .trustStoreBytes(ByteStreams.toByteArray(trustStore))
+ .trustStorePassword(TRUSTSTORE_CLIENT_PWD)
+ .keyStoreBytes(ByteStreams.toByteArray(keyStore))
+ .keyPassword(KEYSTORE_CLIENT_PWD);
+
+ return sslConfigClient.createSSLContext();
+ }
+
+ private SSLContext getServerSslContext() throws IOException {
+ final InputStream trustStore = JdkHttpsServerTest.class.getResourceAsStream(TRUSTSTORE_SERVER_FILE);
+ final InputStream keyStore = JdkHttpsServerTest.class.getResourceAsStream(KEYSTORE_SERVER_FILE);
+
+ final SslConfigurator sslConfigServer = SslConfigurator.newInstance()
+ .keyStoreBytes(ByteStreams.toByteArray(keyStore))
+ .keyPassword(KEYSTORE_SERVER_PWD)
+ .trustStoreBytes(ByteStreams.toByteArray(trustStore))
+ .trustStorePassword(TRUSTSTORE_SERVER_PWD);
+
+ return sslConfigServer.createSSLContext();
+ }
+
+ @After
+ public void tearDown() {
+ if (server != null) {
+ server.stop(0);
+ server = null;
+ }
+ }
+}
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/LifecycleListenerTest.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/LifecycleListenerTest.java
new file mode 100644
index 0000000..229058f
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/LifecycleListenerTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.AbstractContainerLifecycleListener;
+import org.glassfish.jersey.server.spi.Container;
+
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Reload and ContainerLifecycleListener support test.
+ *
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class LifecycleListenerTest extends AbstractJdkHttpServerTester {
+
+ @Path("/one")
+ public static class One {
+ @GET
+ public String get() {
+ return "one";
+ }
+
+ @GET
+ @Path("sub")
+ public String getSub() {
+ return "one-sub";
+ }
+ }
+
+ @Path("/two")
+ public static class Two {
+ @GET
+ public String get() {
+ return "two";
+ }
+ }
+
+ public static class Reloader extends AbstractContainerLifecycleListener {
+ Container container;
+
+ public void reload(ResourceConfig newConfig) {
+ container.reload(newConfig);
+ }
+
+ public void reload() {
+ container.reload();
+ }
+
+ @Override
+ public void onStartup(Container container) {
+ this.container = container;
+ }
+ }
+
+ @Test
+ public void testReload() {
+ final ResourceConfig rc = new ResourceConfig(One.class);
+
+ Reloader reloader = new Reloader();
+ rc.registerInstances(reloader);
+
+ startServer(rc);
+
+ WebTarget r = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals("one-sub", r.path("one/sub").request().get(String.class));
+ assertEquals(404, r.path("two").request().get(Response.class).getStatus());
+
+ // add Two resource
+ reloader.reload(new ResourceConfig(One.class, Two.class));
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals("one-sub", r.path("one/sub").request().get(String.class));
+ assertEquals("two", r.path("two").request().get(String.class));
+ }
+
+ static class StartStopListener extends AbstractContainerLifecycleListener {
+ volatile boolean started;
+ volatile boolean stopped;
+
+ @Override
+ public void onStartup(Container container) {
+ started = true;
+ }
+
+ @Override
+ public void onShutdown(Container container) {
+ stopped = true;
+ }
+ }
+
+ @Test
+ public void testStartupShutdownHooks() {
+ final StartStopListener listener = new StartStopListener();
+
+ startServer(new ResourceConfig(One.class).register(listener));
+
+ WebTarget r = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ assertThat(r.path("one").request().get(String.class), equalTo("one"));
+ assertThat(r.path("two").request().get(Response.class).getStatus(), equalTo(404));
+
+ stopServer();
+
+ assertTrue("ContainerLifecycleListener.onStartup has not been called.", listener.started);
+ assertTrue("ContainerLifecycleListener.onShutdown has not been called.", listener.stopped);
+ }
+}
diff --git a/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/RuntimeDelegateTest.java b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/RuntimeDelegateTest.java
new file mode 100644
index 0000000..26abd46
--- /dev/null
+++ b/containers/jdk-http/src/test/java/org/glassfish/jersey/jdkhttp/RuntimeDelegateTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jdkhttp;
+
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.Set;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriBuilder;
+import javax.ws.rs.ext.RuntimeDelegate;
+
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+
+/**
+ * @author Michal Gajdos
+ */
+public class RuntimeDelegateTest {
+
+ @Path("/")
+ public static class Resource {
+
+ @GET
+ public String get() {
+ return "get";
+ }
+ }
+
+ @Test
+ public void testFetch() throws Exception {
+ final HttpServer server = HttpServer.create(new InetSocketAddress(0), 0);
+ final HttpHandler handler = RuntimeDelegate.getInstance().createEndpoint(new Application() {
+
+ @Override
+ public Set<Class<?>> getClasses() {
+ return Collections.<Class<?>>singleton(Resource.class);
+ }
+ }, HttpHandler.class);
+
+ try {
+ server.createContext("/", handler);
+ server.start();
+
+ final Response response = ClientBuilder.newClient()
+ .target(UriBuilder.fromUri("http://localhost/").port(server.getAddress().getPort()).build())
+ .request()
+ .get();
+
+ assertThat(response.readEntity(String.class), is("get"));
+ } finally {
+ server.stop(0);
+ }
+ }
+}
diff --git a/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_client b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_client
new file mode 100644
index 0000000..d016fd2
--- /dev/null
+++ b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_client
Binary files differ
diff --git a/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_server b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_server
new file mode 100644
index 0000000..a7c93fc
--- /dev/null
+++ b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/keystore_server
Binary files differ
diff --git a/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_client b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_client
new file mode 100644
index 0000000..74784fb
--- /dev/null
+++ b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_client
Binary files differ
diff --git a/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_server b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_server
new file mode 100644
index 0000000..9b26ce4
--- /dev/null
+++ b/containers/jdk-http/src/test/resources/org/glassfish/jersey/jdkhttp/truststore_server
Binary files differ
diff --git a/containers/jersey-servlet-core/pom.xml b/containers/jersey-servlet-core/pom.xml
new file mode 100644
index 0000000..4bc5700
--- /dev/null
+++ b/containers/jersey-servlet-core/pom.xml
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-servlet-core</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-servlet-core</name>
+
+ <description>Jersey core Servlet 2.x implementation</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>javax.servlet</groupId>
+ <artifactId>servlet-api</artifactId>
+ <version>${servlet2.version}</version>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>javax.persistence</groupId>
+ <artifactId>persistence-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <!-- Note: When you're changing these properties change them also in bundles/jax-rs-ri/bundle/pom.xml. -->
+ <Import-Package>
+ javax.persistence.*;resolution:=optional,
+ javax.servlet.*;version="[2.4,5.0)",
+ javax.annotation.*;version=!,
+ *
+ </Import-Package>
+ <Export-Package>org.glassfish.jersey.servlet.*</Export-Package>
+ </instructions>
+ <unpackBundle>true</unpackBundle>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletContainer.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletContainer.java
new file mode 100644
index 0000000..f54fc00
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletContainer.java
@@ -0,0 +1,681 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Iterator;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriBuilder;
+import javax.ws.rs.core.UriBuilderException;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.internal.inject.Providers;
+import org.glassfish.jersey.internal.util.ExtendedLogger;
+import org.glassfish.jersey.internal.util.collection.Value;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.ServerProperties;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.server.spi.ContainerLifecycleListener;
+import org.glassfish.jersey.servlet.internal.LocalizationMessages;
+import org.glassfish.jersey.servlet.internal.ResponseWriter;
+import org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider;
+import org.glassfish.jersey.uri.UriComponent;
+
+/**
+ * A {@link javax.servlet.Servlet} or {@link Filter} for deploying root resource classes.
+ * <p />
+ * The following sections make reference to initialization parameters. Unless
+ * otherwise specified the initialization parameters apply to both server
+ * and filter initialization parameters.
+ * <p />
+ * The servlet or filter may be configured to have an initialization
+ * parameter {@value ServletProperties#JAXRS_APPLICATION_CLASS}
+ * (see {@link org.glassfish.jersey.servlet.ServletProperties#JAXRS_APPLICATION_CLASS}) and whose value is a
+ * fully qualified name of a class that implements {@link javax.ws.rs.core.Application}.
+ * The class is instantiated as a singleton component
+ * managed by the runtime, and injection may be performed (the artifacts that
+ * may be injected are limited to injectable providers registered when
+ * the servlet or filter is configured).
+ * <p />
+ * If the initialization parameter {@value ServletProperties#JAXRS_APPLICATION_CLASS}
+ * is not present and a initialization parameter {@value org.glassfish.jersey.server.ServerProperties#PROVIDER_PACKAGES}
+ * is present (see {@link ServerProperties#PROVIDER_PACKAGES}) a new instance of
+ * {@link ResourceConfig} with this configuration is created. The initialization parameter
+ * {@value org.glassfish.jersey.server.ServerProperties#PROVIDER_PACKAGES} MUST be set to provide one or
+ * more package names. Each package name MUST be separated by ';'.
+ * <p />
+ * If none of the above resource configuration related initialization parameters
+ * are present a new instance of {@link ResourceConfig} with {@link WebAppResourcesScanner}
+ * is created. The initialization parameter {@value org.glassfish.jersey.server.ServerProperties#PROVIDER_CLASSPATH}
+ * is present (see {@link ServerProperties#PROVIDER_CLASSPATH}) MAY be
+ * set to provide one or more resource paths. Each path MUST be separated by ';'.
+ * If the initialization parameter is not present then the following resource
+ * paths are utilized: {@code "/WEB-INF/lib"} and {@code "/WEB-INF/classes"}.
+ * <p />
+ * All initialization parameters are added as properties of the created
+ * {@link ResourceConfig}.
+ * <p />
+ * A new {@link org.glassfish.jersey.server.ApplicationHandler} instance will be created and configured such
+ * that the following classes may be injected onto a root resource, provider
+ * and {@link javax.ws.rs.core.Application} classes using {@link javax.ws.rs.core.Context
+ * @Context} annotation:
+ * {@link HttpServletRequest}, {@link HttpServletResponse},
+ * {@link ServletContext}, {@link javax.servlet.ServletConfig} and {@link WebConfig}.
+ * If this class is used as a Servlet then the {@link javax.servlet.ServletConfig} class may
+ * be injected. If this class is used as a servlet filter then the {@link FilterConfig}
+ * class may be injected. {@link WebConfig} may be injected to abstract
+ * servlet or filter deployment.
+ * <p />
+ * Persistence units that may be injected must be configured in web.xml
+ * in the normal way plus an additional servlet parameter to enable the
+ * Jersey servlet to locate them in JNDI. E.g. with the following
+ * persistence unit configuration:
+ * <pre>{@code
+ * <persistence-unit-ref>
+ * <persistence-unit-ref-name>persistence/widget</persistence-unit-ref-name>
+ * <persistence-unit-name>WidgetPU</persistence-unit-name>
+ * </persistence-unit-ref>
+ * }</pre>
+ * the Jersey servlet requires an additional servlet parameter as
+ * follows:
+ * <pre>{@code
+ * <init-param>
+ * <param-name>unit:WidgetPU</param-name>
+ * <param-value>persistence/widget</param-value>
+ * </init-param>
+ * }</pre>
+ * Given the above, Jersey will inject the {@link javax.persistence.EntityManagerFactory EntityManagerFactory} found
+ * at {@code java:comp/env/persistence/widget} in JNDI when encountering a
+ * field or parameter annotated with {@code @PersistenceUnit(unitName="WidgetPU")}.
+ *
+ * @author Paul Sandoz
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ * @author Michal Gajdos
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class ServletContainer extends HttpServlet implements Filter, Container {
+
+ private static final long serialVersionUID = 3932047066686065219L;
+ private static final ExtendedLogger LOGGER =
+ new ExtendedLogger(Logger.getLogger(ServletContainer.class.getName()), Level.FINEST);
+
+ private transient FilterConfig filterConfig;
+ private transient WebComponent webComponent;
+ private transient ResourceConfig resourceConfig;
+ private transient Pattern staticContentPattern;
+ private transient String filterContextPath;
+ private transient List<String> filterUrlMappings;
+
+ private transient volatile ContainerLifecycleListener containerListener;
+
+ /**
+ * Initiate the Web component.
+ *
+ * @param webConfig the Web configuration.
+ * @throws javax.servlet.ServletException in case of an initialization failure
+ */
+ protected void init(final WebConfig webConfig) throws ServletException {
+ webComponent = new WebComponent(webConfig, resourceConfig);
+ containerListener = webComponent.appHandler;
+ containerListener.onStartup(this);
+ }
+
+ /**
+ * Create Jersey Servlet container.
+ */
+ public ServletContainer() {
+ }
+
+ /**
+ * Create Jersey Servlet container.
+ *
+ * @param resourceConfig container configuration.
+ */
+ public ServletContainer(final ResourceConfig resourceConfig) {
+ this.resourceConfig = resourceConfig;
+ }
+
+ /**
+ * Dispatches client requests to the protected
+ * {@code service} method. There's no need to
+ * override this method.
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ * @param res the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ * @throws IOException if an input or output error occurs
+ * while the servlet is handling the
+ * HTTP request
+ * @throws ServletException if the HTTP request cannot
+ * be handled
+ * @see javax.servlet.Servlet#service
+ */
+ @Override
+ public void service(final ServletRequest req, final ServletResponse res)
+ throws ServletException, IOException {
+ final HttpServletRequest request;
+ final HttpServletResponse response;
+
+ if (!(req instanceof HttpServletRequest && res instanceof HttpServletResponse)) {
+ throw new ServletException("non-HTTP request or response");
+ }
+
+ request = (HttpServletRequest) req;
+ response = (HttpServletResponse) res;
+
+ service(request, response);
+ }
+
+ /**
+ * Receives standard HTTP requests from the public {@code service} method and dispatches
+ * them to the {@code do}<i>XXX</i> methods defined in
+ * this class. This method is an HTTP-specific version of the
+ * {@link javax.servlet.Servlet#service} method. There's no
+ * need to override this method.
+ *
+ * @param request the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ * @param response the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ * @throws IOException if an input or output error occurs
+ * while the servlet is handling the
+ * HTTP request
+ * @throws ServletException if the HTTP request
+ * cannot be handled
+ * @see javax.servlet.Servlet#service
+ */
+ @Override
+ protected void service(final HttpServletRequest request, final HttpServletResponse response)
+ throws ServletException, IOException {
+ /**
+ * There is an annoying edge case where the service method is
+ * invoked for the case when the URI is equal to the deployment URL
+ * minus the '/', for example http://locahost:8080/HelloWorldWebApp
+ */
+ final String servletPath = request.getServletPath();
+ final StringBuffer requestUrl = request.getRequestURL();
+ final String requestURI = request.getRequestURI();
+
+ // final String pathInfo = request.getPathInfo();
+ // final boolean checkPathInfo = pathInfo == null || pathInfo.isEmpty() || pathInfo.equals("/");
+ // if (checkPathInfo && !request.getRequestURI().endsWith("/")) {
+ // Only do this if the last segment of the servlet path does not contain '.'
+ // This handles the case when the extension mapping is used with the servlet
+ // see issue 506
+ // This solution does not require parsing the deployment descriptor,
+ // however still leaves it broken for the very rare case if a standard path
+ // servlet mapping would include dot in the last segment (e.g. /.webresources/*)
+ // and somebody would want to hit the root resource without the trailing slash
+ // final int i = servletPath.lastIndexOf('/');
+ // if (servletPath.substring(i + 1).indexOf('.') < 0) {
+ // TODO (+ handle request URL with invalid characters - see the creation of absoluteUriBuilder below)
+ // if (webComponent.getResourceConfig().getFeature(ResourceConfig.FEATURE_REDIRECT)) {
+ // URI l = UriBuilder.fromUri(request.getRequestURL().toString()).
+ // path("/").
+ // replaceQuery(request.getQueryString()).build();
+ //
+ // response.setStatus(307);
+ // response.setHeader("Location", l.toASCIIString());
+ // return;
+ // } else {
+ // pathInfo = "/";
+ // requestURL.append("/");
+ // requestURI += "/";
+ // }
+ // }
+ // }
+
+ /**
+ * The HttpServletRequest.getRequestURL() contains the complete URI
+ * minus the query and fragment components.
+ */
+ final UriBuilder absoluteUriBuilder;
+ try {
+ absoluteUriBuilder = UriBuilder.fromUri(requestUrl.toString());
+ } catch (final IllegalArgumentException iae) {
+ setResponseForInvalidUri(response, iae);
+ return;
+ }
+
+ /**
+ * The HttpServletRequest.getPathInfo() and
+ * HttpServletRequest.getServletPath() are in decoded form.
+ *
+ * On some servlet implementations the getPathInfo() removed
+ * contiguous '/' characters. This is problematic if URIs
+ * are embedded, for example as the last path segment.
+ * We need to work around this and not use getPathInfo
+ * for the decodedPath.
+ */
+ final String decodedBasePath = request.getContextPath() + servletPath + "/";
+
+ final String encodedBasePath = UriComponent.encode(decodedBasePath,
+ UriComponent.Type.PATH);
+
+ if (!decodedBasePath.equals(encodedBasePath)) {
+ throw new ProcessingException("The servlet context path and/or the "
+ + "servlet path contain characters that are percent encoded");
+ }
+
+ final URI baseUri;
+ final URI requestUri;
+ try {
+ baseUri = absoluteUriBuilder.replacePath(encodedBasePath).build();
+ String queryParameters = ContainerUtils.encodeUnsafeCharacters(request.getQueryString());
+ if (queryParameters == null) {
+ queryParameters = "";
+ }
+
+ requestUri = absoluteUriBuilder.replacePath(requestURI)
+ .replaceQuery(queryParameters)
+ .build();
+ } catch (final UriBuilderException | IllegalArgumentException ex) {
+ setResponseForInvalidUri(response, ex);
+ return;
+ }
+
+ service(baseUri, requestUri, request, response);
+ }
+
+ private void setResponseForInvalidUri(final HttpServletResponse response, final Throwable throwable) throws IOException {
+ LOGGER.log(Level.FINER, "Error while processing request.", throwable);
+
+ final Response.Status badRequest = Response.Status.BAD_REQUEST;
+ if (webComponent.configSetStatusOverSendError) {
+ response.reset();
+ //noinspection deprecation
+ response.setStatus(badRequest.getStatusCode(), badRequest.getReasonPhrase());
+ } else {
+ response.sendError(badRequest.getStatusCode(), badRequest.getReasonPhrase());
+ }
+ }
+
+ @Override
+ public void destroy() {
+ super.destroy();
+
+ final ContainerLifecycleListener listener = containerListener;
+ if (listener != null) {
+ listener.onShutdown(this);
+ }
+ }
+
+ @Override
+ public void init() throws ServletException {
+ init(new WebServletConfig(this));
+ }
+
+ /**
+ * Dispatch client requests to a resource class.
+ *
+ * @param baseUri the base URI of the request.
+ * @param requestUri the URI of the request.
+ * @param request the {@link javax.servlet.http.HttpServletRequest} object that contains the request the client made to
+ * the Web component.
+ * @param response the {@link javax.servlet.http.HttpServletResponse} object that contains the response the Web component
+ * returns to the client.
+ * @return lazily initialized response status code {@link Value value provider}. If not resolved in the moment of call to
+ * {@link Value#get()}, {@code -1} is returned.
+ * @throws IOException if an input or output error occurs while the Web component is handling the HTTP request.
+ * @throws ServletException if the HTTP request cannot be handled.
+ */
+ public Value<Integer> service(final URI baseUri, final URI requestUri, final HttpServletRequest request,
+ final HttpServletResponse response) throws ServletException, IOException {
+ return webComponent.service(baseUri, requestUri, request, response);
+ }
+
+ /**
+ * Dispatch client requests to a resource class and returns {@link ResponseWriter},
+ * Servlet's {@link org.glassfish.jersey.server.spi.ContainerResponseWriter} implementation.
+ *
+ * @param baseUri the base URI of the request.
+ * @param requestUri the URI of the request.
+ * @param request the {@link javax.servlet.http.HttpServletRequest} object that contains the request the client made to
+ * the Web component.
+ * @param response the {@link javax.servlet.http.HttpServletResponse} object that contains the response the Web component
+ * returns to the client.
+ * @return returns {@link ResponseWriter}, Servlet's {@link org.glassfish.jersey.server.spi.ContainerResponseWriter}
+ * implementation, into which processed request response was written to.
+ * @throws IOException if an input or output error occurs while the Web component is handling the HTTP request.
+ * @throws ServletException if the HTTP request cannot be handled.
+ */
+ private ResponseWriter serviceImpl(final URI baseUri, final URI requestUri, final HttpServletRequest request,
+ final HttpServletResponse response) throws ServletException, IOException {
+ return webComponent.serviceImpl(baseUri, requestUri, request, response);
+ }
+
+ // Filter
+ @Override
+ public void init(final FilterConfig filterConfig) throws ServletException {
+ this.filterConfig = filterConfig;
+ init(new WebFilterConfig(filterConfig));
+
+ final String regex = (String) getConfiguration().getProperty(ServletProperties.FILTER_STATIC_CONTENT_REGEX);
+ if (regex != null && !regex.isEmpty()) {
+ try {
+ staticContentPattern = Pattern.compile(regex);
+ } catch (final PatternSyntaxException ex) {
+ throw new ContainerException(LocalizationMessages.INIT_PARAM_REGEX_SYNTAX_INVALID(
+ regex, ServletProperties.FILTER_STATIC_CONTENT_REGEX), ex);
+ }
+ }
+
+ this.filterContextPath = filterConfig.getInitParameter(ServletProperties.FILTER_CONTEXT_PATH);
+ if (filterContextPath != null) {
+ if (filterContextPath.isEmpty()) {
+ filterContextPath = null;
+ } else {
+ if (!filterContextPath.startsWith("/")) {
+ filterContextPath = '/' + filterContextPath;
+ }
+ if (filterContextPath.endsWith("/")) {
+ filterContextPath = filterContextPath.substring(0, filterContextPath.length() - 1);
+ }
+ }
+ }
+
+ // get the url-pattern defined (e.g.) in the filter-mapping section of web.xml
+ final FilterUrlMappingsProvider filterUrlMappingsProvider = getFilterUrlMappingsProvider();
+ if (filterUrlMappingsProvider != null) {
+ filterUrlMappings = filterUrlMappingsProvider.getFilterUrlMappings(filterConfig);
+ }
+
+ // we need either the url-pattern from the filter mapping (in case of Servlet 3) or specific init-param to
+ // determine the baseUri and request relative URI. If we do not have either one, the app will most likely
+ // not work (won't be accessible)
+ if (filterUrlMappings == null && filterContextPath == null) {
+ LOGGER.warning(LocalizationMessages.FILTER_CONTEXT_PATH_MISSING());
+ }
+ }
+
+ @Override
+ public void doFilter(final ServletRequest servletRequest,
+ final ServletResponse servletResponse,
+ final FilterChain filterChain)
+ throws IOException, ServletException {
+ try {
+ doFilter((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse, filterChain);
+ } catch (final ClassCastException e) {
+ throw new ServletException("non-HTTP request or response", e);
+ }
+ }
+
+ /**
+ * Get the servlet context for the servlet or filter, depending on
+ * how this class is registered.
+ *
+ * @return the servlet context for the servlet or filter.
+ */
+ @Override
+ public ServletContext getServletContext() {
+ if (filterConfig != null) {
+ return filterConfig.getServletContext();
+ }
+
+ return super.getServletContext();
+ }
+
+ /**
+ * Dispatches client requests to the
+ * {@link #service(URI, URI, HttpServletRequest, HttpServletResponse)} method.
+ * <p />
+ * If the servlet path matches the regular expression declared by the
+ * property {@link ServletProperties#FILTER_STATIC_CONTENT_REGEX} then the
+ * request is forwarded to the next filter in the filter chain so that the
+ * underlying servlet engine can process the request otherwise Jersey
+ * will process the request.
+ *
+ * @param request the {@link HttpServletRequest} object that
+ * contains the request the client made to
+ * the servlet.
+ * @param response the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client.
+ * @param chain the chain of filters from which the next filter can be invoked.
+ * @throws java.io.IOException in case of an I/O error.
+ * @throws javax.servlet.ServletException in case of an error while executing the
+ * filter chain.
+ */
+ public void doFilter(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain)
+ throws IOException, ServletException {
+ if (request.getAttribute("javax.servlet.include.request_uri") != null) {
+ final String includeRequestURI = (String) request.getAttribute("javax.servlet.include.request_uri");
+
+ if (!includeRequestURI.equals(request.getRequestURI())) {
+ doFilter(request, response, chain,
+ includeRequestURI,
+ (String) request.getAttribute("javax.servlet.include.servlet_path"),
+ (String) request.getAttribute("javax.servlet.include.query_string"));
+ return;
+ }
+ }
+
+ /**
+ * JERSEY-880 - WAS interprets HttpServletRequest#getServletPath() and HttpServletRequest#getPathInfo()
+ * differently when accessing a static resource.
+ */
+ final String servletPath = request.getServletPath()
+ + (request.getPathInfo() == null ? "" : request.getPathInfo());
+
+ doFilter(request, response, chain,
+ request.getRequestURI(),
+ servletPath,
+ request.getQueryString());
+ }
+
+ private void doFilter(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain,
+ final String requestURI, final String servletPath, final String queryString)
+ throws IOException, ServletException {
+ // if we match the static content regular expression lets delegate to
+ // the filter chain to use the default container servlets & handlers
+ final Pattern p = getStaticContentPattern();
+ if (p != null && p.matcher(servletPath).matches()) {
+ chain.doFilter(request, response);
+ return;
+ }
+
+ if (filterContextPath != null) {
+ if (!servletPath.startsWith(filterContextPath)) {
+ throw new ContainerException(LocalizationMessages.SERVLET_PATH_MISMATCH(servletPath, filterContextPath));
+ //TODO:
+ // } else if (servletPath.length() == filterContextPath.length()) {
+ // // Path does not end in a slash, may need to redirect
+ // if (webComponent.getResourceConfig().getFeature(ResourceConfig.FEATURE_REDIRECT)) {
+ // URI l = UriBuilder.fromUri(request.getRequestURL().toString()).
+ // path("/").
+ // replaceQuery(queryString).build();
+ //
+ // response.setStatus(307);
+ // response.setHeader("Location", l.toASCIIString());
+ // return;
+ // } else {
+ // requestURI += "/";
+ // }
+ }
+ }
+
+ final URI baseUri;
+ final URI requestUri;
+ try {
+ final UriBuilder absoluteUriBuilder = UriBuilder.fromUri(request.getRequestURL().toString());
+
+ // depending on circumstances, use the correct path to replace in the absolute request URI
+ final String pickedUrlMapping = pickUrlMapping(request.getRequestURL().toString(), filterUrlMappings);
+ final String replacingPath = pickedUrlMapping != null
+ ? pickedUrlMapping
+ : (filterContextPath != null ? filterContextPath : "");
+
+ baseUri = absoluteUriBuilder.replacePath(request.getContextPath()).path(replacingPath).path("/").build();
+
+
+ requestUri = absoluteUriBuilder.replacePath(requestURI)
+ .replaceQuery(ContainerUtils.encodeUnsafeCharacters(queryString))
+ .build();
+ } catch (final IllegalArgumentException iae) {
+ setResponseForInvalidUri(response, iae);
+ return;
+ }
+
+ final ResponseWriter responseWriter = serviceImpl(baseUri, requestUri, request, response);
+
+ // If forwarding is configured and response is a 404 with no entity
+ // body then call the next filter in the chain
+
+ if (webComponent.forwardOn404 && !response.isCommitted()) {
+ boolean hasEntity = false;
+ Response.StatusType status = null;
+ if (responseWriter.responseContextResolved()) {
+ final ContainerResponse responseContext = responseWriter.getResponseContext();
+ hasEntity = responseContext.hasEntity();
+ status = responseContext.getStatusInfo();
+ }
+ if (!hasEntity && status == Response.Status.NOT_FOUND) {
+ // lets clear the response to OK before we forward to the next in the chain
+ // as OK is the default set by servlet containers before filters/servlets do any work
+ // so lets hide our footsteps and pretend we were never in the chain at all and let the
+ // next filter or servlet return the 404 if they can't find anything to return
+ //
+ // We could add an optional flag to disable this step if anyone can ever find a case where
+ // this causes a problem, though I suspect any problems will really be with downstream
+ // servlets not correctly setting an error status if they cannot find something to return
+ response.setStatus(HttpServletResponse.SC_OK);
+ chain.doFilter(request, response);
+ }
+ }
+ }
+
+ /**
+ * Picks the most suitable url mapping (in case more than one is defined) based on the request URI.
+ *
+ * @param requestUri String representation of the request URI
+ * @param filterUrlMappings set of configured filter url-patterns
+ * @return the most suitable context path, or {@code null} if empty
+ */
+ private String pickUrlMapping(final String requestUri, final List<String> filterUrlMappings) {
+ if (filterUrlMappings == null || filterUrlMappings.isEmpty()) {
+ return null;
+ }
+
+ if (filterUrlMappings.size() == 1) {
+ return filterUrlMappings.get(0);
+ }
+
+ for (final String pattern : filterUrlMappings) {
+ if (requestUri.contains(pattern)) {
+ return pattern;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Resolve the {@link FilterUrlMappingsProvider} service via hk2.
+ *
+ * Will only work in Servlet 3 container, as the older API version
+ * does not provide access to the filter mapping structure.
+ *
+ * @return {@code FilterContextPath} instance, if available, {@code null} otherwise.
+ */
+ private FilterUrlMappingsProvider getFilterUrlMappingsProvider() {
+ FilterUrlMappingsProvider filterUrlMappingsProvider = null;
+ final Iterator<FilterUrlMappingsProvider> providers = Providers.getAllProviders(
+ getApplicationHandler().getInjectionManager(), FilterUrlMappingsProvider.class).iterator();
+ if (providers.hasNext()) {
+ filterUrlMappingsProvider = providers.next();
+ }
+ return filterUrlMappingsProvider;
+ }
+
+ /**
+ * Get the static content path pattern.
+ *
+ * @return the {@link Pattern} compiled from a regular expression that is
+ * the property value of {@link ServletProperties#FILTER_STATIC_CONTENT_REGEX}.
+ * A {@code null} value will be returned if the property is not set or is
+ * an empty String.
+ */
+ protected Pattern getStaticContentPattern() {
+ return staticContentPattern;
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return webComponent.appHandler.getConfiguration();
+ }
+
+ @Override
+ public void reload() {
+ reload(getConfiguration());
+ }
+
+ @Override
+ public void reload(final ResourceConfig configuration) {
+ try {
+ containerListener.onShutdown(this);
+
+ webComponent = new WebComponent(webComponent.webConfig, configuration);
+ containerListener = webComponent.appHandler;
+ containerListener.onReload(this);
+ containerListener.onStartup(this);
+ } catch (final ServletException ex) {
+ LOGGER.log(Level.SEVERE, "Reload failed", ex);
+ }
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return webComponent.appHandler;
+ }
+
+ /**
+ * Get {@link WebComponent} used by this servlet container.
+ *
+ * @return The web component.
+ */
+ @SuppressWarnings("UnusedDeclaration")
+ public WebComponent getWebComponent() {
+ return webComponent;
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletProperties.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletProperties.java
new file mode 100644
index 0000000..e6ea54b
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletProperties.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import org.glassfish.jersey.internal.util.PropertiesClass;
+
+/**
+ * Jersey servlet container configuration properties.
+ *
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+@PropertiesClass
+public final class ServletProperties {
+
+ /**
+ * If set, indicates the URL pattern of the Jersey servlet filter context path.
+ * <p>
+ * If the URL pattern of a filter is set to a base path and a wildcard,
+ * such as "/base/*", then this property can be used to declare a filter
+ * context path that behaves in the same manner as the Servlet context
+ * path for determining the base URI of the application. (Note that with
+ * the Servlet 2.x API it is not possible to determine the URL pattern
+ * without parsing the {@code web.xml}, hence why this property is necessary.)
+ * <p>
+ * The property is only applicable when {@link ServletContainer Jersey servlet
+ * container} is configured to run as a {@link javax.servlet.Filter}, otherwise this property
+ * will be ignored.
+ * <p>
+ * The value of the property may consist of one or more path segments separate by
+ * {@code '/'}.
+ * <p></p>
+ * A default value is not set.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ public static final String FILTER_CONTEXT_PATH = "jersey.config.servlet.filter.contextPath";
+
+ /**
+ * If set to {@code true} and a 404 response with no entity body is returned
+ * from either the runtime or the application then the runtime forwards the
+ * request to the next filter in the filter chain. This enables another filter
+ * or the underlying servlet engine to process the request. Before the request
+ * is forwarded the response status is set to 200.
+ * <p>
+ * This property is an alternative to setting a {@link #FILTER_STATIC_CONTENT_REGEX
+ * static content regular expression} and requires less configuration. However,
+ * application code, such as methods corresponding to sub-resource locators,
+ * may be invoked when this feature is enabled.
+ * <p></p>
+ * The property is only applicable when {@link ServletContainer Jersey servlet
+ * container} is configured to run as a {@link javax.servlet.Filter}, otherwise
+ * this property will be ignored.
+ * <p></p>
+ * Application code, such as methods corresponding to sub-resource locators
+ * may be invoked when this feature is enabled.
+ * <p>
+ * The default value is {@code false}.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ public static final String FILTER_FORWARD_ON_404 = "jersey.config.servlet.filter.forwardOn404";
+
+ /**
+ * If set the regular expression is used to match an incoming servlet path URI
+ * to some web page content such as static resources or JSPs to be handled
+ * by the underlying servlet engine.
+ * <p></p>
+ * The property is only applicable when {@link ServletContainer Jersey servlet
+ * container} is configured to run as a {@link javax.servlet.Filter}, otherwise
+ * this property will be ignored. If a servlet path matches this regular
+ * expression then the filter forwards the request to the next filter in the
+ * filter chain so that the underlying servlet engine can process the request
+ * otherwise Jersey will process the request. For example if you set the value
+ * to {@code /(image|css)/.*} then you can serve up images and CSS files
+ * for your Implicit or Explicit Views while still processing your JAX-RS
+ * resources.
+ * <p></p>
+ * The type of this property must be a String and the value must be a valid
+ * regular expression.
+ * <p></p>
+ * A default value is not set.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ public static final String FILTER_STATIC_CONTENT_REGEX = "jersey.config.servlet.filter.staticContentRegex";
+
+ /**
+ * Application configuration initialization property whose value is a fully
+ * qualified class name of a class that implements {@link javax.ws.rs.core.Application}.
+ * <p></p>
+ * A default value is not set.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ // TODO implement generic support
+ public static final String JAXRS_APPLICATION_CLASS = "javax.ws.rs.Application";
+
+ /**
+ * Indicates that Jersey should scan the whole web app for application-specific resources and
+ * providers. If the property is present and the value is not {@code false}, the whole web app
+ * will be scanned for JAX-RS root resources (annotated with {@link javax.ws.rs.Path @Path})
+ * and providers (annotated with {@link javax.ws.rs.ext.Provider @Provider}).
+ * <p></p>
+ * The property value MUST be an instance of {@link String}. The allowed values are {@code true}
+ * and {@code false}.
+ * <p></p>
+ * A default value is not set.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ public static final String PROVIDER_WEB_APP = "jersey.config.servlet.provider.webapp";
+
+ /**
+ * If {@code true} then query parameters will not be treated as form parameters (e.g. injectable using
+ * {@link javax.ws.rs.FormParam}) in case a Form request is processed by server.
+ * <p>
+ * The default value is {@code false}.
+ * </p>
+ * <p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ * </p>
+ *
+ * @since 2.16
+ */
+ public static final String QUERY_PARAMS_AS_FORM_PARAMS_DISABLED = "jersey.config.servlet.form.queryParams.disabled";
+
+ /**
+ * Identifies the object that will be used as a parent {@code HK2 ServiceLocator} in the Jersey
+ * {@link WebComponent}.
+ * <p></p>
+ * This property gives a possibility to use HK2 services that are registered and/or created
+ * outside of the Jersey server context.
+ * <p></p>
+ * By default this property is not set.
+ * <p></p>
+ * The name of the configuration property is <tt>{@value}</tt>.
+ */
+ public static final String SERVICE_LOCATOR = "jersey.config.servlet.context.serviceLocator";
+
+ private ServletProperties() {
+ // prevents instantiation
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletPropertiesDelegate.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletPropertiesDelegate.java
new file mode 100644
index 0000000..7a17521
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/ServletPropertiesDelegate.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.glassfish.jersey.internal.PropertiesDelegate;
+
+/**
+ * @author Martin Matula
+ */
+class ServletPropertiesDelegate implements PropertiesDelegate {
+ private final HttpServletRequest request;
+
+ public ServletPropertiesDelegate(HttpServletRequest request) {
+ this.request = request;
+ }
+
+ @Override
+ public Object getProperty(String name) {
+ return request.getAttribute(name);
+ }
+
+ @Override
+ public Collection<String> getPropertyNames() {
+ //noinspection unchecked
+ return Collections.list(request.getAttributeNames());
+ }
+
+ @Override
+ public void setProperty(String name, Object object) {
+ request.setAttribute(name, object);
+ }
+
+ @Override
+ public void removeProperty(String name) {
+ request.removeAttribute(name);
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebAppResourcesScanner.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebAppResourcesScanner.java
new file mode 100644
index 0000000..f80464a
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebAppResourcesScanner.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+import javax.servlet.ServletContext;
+
+import org.glassfish.jersey.server.internal.AbstractResourceFinderAdapter;
+import org.glassfish.jersey.server.internal.scanning.JarFileScanner;
+import org.glassfish.jersey.server.internal.scanning.ResourceFinderException;
+import org.glassfish.jersey.server.internal.scanning.CompositeResourceFinder;
+
+/**
+ * A scanner that recursively scans resources within a Web application.
+ *
+ * @author Paul Sandoz
+ */
+final class WebAppResourcesScanner extends AbstractResourceFinderAdapter {
+
+ private static final String[] paths = new String[] {"/WEB-INF/lib/", "/WEB-INF/classes/"};
+
+ private final ServletContext sc;
+ private CompositeResourceFinder compositeResourceFinder = new CompositeResourceFinder();
+
+ /**
+ * Scan from a set of web resource paths.
+ * <p/>
+ *
+ * @param sc {@link ServletContext}.
+ */
+ WebAppResourcesScanner(final ServletContext sc) {
+ this.sc = sc;
+
+ processPaths(paths);
+ }
+
+ private void processPaths(final String... paths) {
+ for (final String path : paths) {
+
+ final Set<String> resourcePaths = sc.getResourcePaths(path);
+ if (resourcePaths == null) {
+ break;
+ }
+
+ compositeResourceFinder.push(new AbstractResourceFinderAdapter() {
+
+ private final Deque<String> resourcePathsStack = new LinkedList<String>() {
+
+ private static final long serialVersionUID = 3109256773218160485L;
+
+ {
+ for (final String resourcePath : resourcePaths) {
+ push(resourcePath);
+ }
+ }
+ };
+
+ private String current;
+ private String next;
+
+ @Override
+ public boolean hasNext() {
+ while (next == null && !resourcePathsStack.isEmpty()) {
+ next = resourcePathsStack.pop();
+
+ if (next.endsWith("/")) {
+ processPaths(next);
+ next = null;
+ } else if (next.endsWith(".jar")) {
+ try {
+ compositeResourceFinder.push(new JarFileScanner(sc.getResourceAsStream(next), "", true));
+ } catch (final IOException ioe) {
+ throw new ResourceFinderException(ioe);
+ }
+ next = null;
+ }
+ }
+
+ return next != null;
+ }
+
+ @Override
+ public String next() {
+ if (next != null || hasNext()) {
+ current = next;
+ next = null;
+ return current;
+ }
+
+ throw new NoSuchElementException();
+ }
+
+ @Override
+ public InputStream open() {
+ return sc.getResourceAsStream(current);
+ }
+
+ @Override
+ public void reset() {
+ throw new UnsupportedOperationException();
+ }
+ });
+
+ }
+ }
+
+ @Override
+ public boolean hasNext() {
+ return compositeResourceFinder.hasNext();
+ }
+
+ @Override
+ public String next() {
+ return compositeResourceFinder.next();
+ }
+
+ @Override
+ public InputStream open() {
+ return compositeResourceFinder.open();
+ }
+
+ @Override
+ public void close() {
+ compositeResourceFinder.close();
+ }
+
+ @Override
+ public void reset() {
+ compositeResourceFinder = new CompositeResourceFinder();
+ processPaths(paths);
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebComponent.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebComponent.java
new file mode 100644
index 0000000..84962be
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebComponent.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.security.AccessController;
+import java.security.Principal;
+import java.security.PrivilegedActionException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.core.Form;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.SecurityContext;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.internal.ServiceFinderBinder;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+import org.glassfish.jersey.internal.inject.Providers;
+import org.glassfish.jersey.internal.inject.ReferencingFactory;
+import org.glassfish.jersey.internal.util.ReflectionHelper;
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.internal.util.collection.Value;
+import org.glassfish.jersey.internal.util.collection.Values;
+import org.glassfish.jersey.message.internal.HeaderValueException;
+import org.glassfish.jersey.message.internal.MediaTypes;
+import org.glassfish.jersey.process.internal.RequestScoped;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.BackgroundSchedulerLiteral;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.ServerProperties;
+import org.glassfish.jersey.server.internal.InternalServerProperties;
+import org.glassfish.jersey.server.spi.RequestScopedInitializer;
+import org.glassfish.jersey.servlet.internal.LocalizationMessages;
+import org.glassfish.jersey.servlet.internal.PersistenceUnitBinder;
+import org.glassfish.jersey.servlet.internal.ResponseWriter;
+import org.glassfish.jersey.servlet.internal.ServletContainerProviderFactory;
+import org.glassfish.jersey.servlet.internal.Utils;
+import org.glassfish.jersey.servlet.internal.spi.ExtendedServletContainerProvider;
+import org.glassfish.jersey.servlet.internal.spi.RequestContextProvider;
+import org.glassfish.jersey.servlet.internal.spi.RequestScopedInitializerProvider;
+import org.glassfish.jersey.servlet.internal.spi.ServletContainerProvider;
+import org.glassfish.jersey.servlet.spi.AsyncContextDelegate;
+import org.glassfish.jersey.servlet.spi.AsyncContextDelegateProvider;
+import org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider;
+import org.glassfish.jersey.uri.UriComponent;
+
+/**
+ * An common Jersey web component that may be extended by a Servlet and/or
+ * Filter implementation, or encapsulated by a Servlet or Filter implementation.
+ *
+ * @author Paul Sandoz
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ * @author Martin Matula
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class WebComponent {
+
+ private static final Logger LOGGER = Logger.getLogger(WebComponent.class.getName());
+
+ private static final Type REQUEST_TYPE = (new GenericType<Ref<HttpServletRequest>>() {}).getType();
+ private static final Type RESPONSE_TYPE = (new GenericType<Ref<HttpServletResponse>>() {}).getType();
+
+ private static final AsyncContextDelegate DEFAULT_ASYNC_DELEGATE = new AsyncContextDelegate() {
+
+ @Override
+ public void suspend() throws IllegalStateException {
+ throw new UnsupportedOperationException(LocalizationMessages.ASYNC_PROCESSING_NOT_SUPPORTED());
+ }
+
+ @Override
+ public void complete() {
+ }
+ };
+
+ private final RequestScopedInitializerProvider requestScopedInitializer;
+ private final boolean requestResponseBindingExternalized;
+
+ private static final RequestScopedInitializerProvider DEFAULT_REQUEST_SCOPE_INITIALIZER_PROVIDER =
+ context -> (RequestScopedInitializer) injectionManager -> {
+ injectionManager.<Ref<HttpServletRequest>>getInstance(REQUEST_TYPE).set(context.getHttpServletRequest());
+ injectionManager.<Ref<HttpServletResponse>>getInstance(RESPONSE_TYPE).set(context.getHttpServletResponse());
+ };
+
+ /**
+ * Return the first found {@link AsyncContextDelegateProvider}
+ * (via {@link Providers#getAllProviders(InjectionManager, Class)}) or {@code #DEFAULT_ASYNC_DELEGATE} if
+ * other delegate cannot be found.
+ *
+ * @return a non-null AsyncContextDelegateProvider.
+ */
+ private AsyncContextDelegateProvider getAsyncExtensionDelegate() {
+ final Iterator<AsyncContextDelegateProvider> providers = Providers.getAllProviders(appHandler.getInjectionManager(),
+ AsyncContextDelegateProvider.class).iterator();
+ if (providers.hasNext()) {
+ return providers.next();
+ }
+
+ return (request, response) -> DEFAULT_ASYNC_DELEGATE;
+ }
+
+ @SuppressWarnings("JavaDoc")
+ private static class HttpServletRequestReferencingFactory extends ReferencingFactory<HttpServletRequest> {
+
+ @Inject
+ public HttpServletRequestReferencingFactory(final Provider<Ref<HttpServletRequest>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ @SuppressWarnings("JavaDoc")
+ private static class HttpServletResponseReferencingFactory extends ReferencingFactory<HttpServletResponse> {
+
+ @Inject
+ public HttpServletResponseReferencingFactory(final Provider<Ref<HttpServletResponse>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ private final class WebComponentBinder extends AbstractBinder {
+
+ private final Map<String, Object> applicationProperties;
+
+ /**
+ * Create binder for {@link WebComponent} passing a map of properties to determine whether certain features are allowed
+ * or
+ * not.
+ *
+ * @param applicationProperties map of properties to determine whether certain features are allowed or not.
+ */
+ private WebComponentBinder(final Map<String, Object> applicationProperties) {
+ this.applicationProperties = applicationProperties;
+ }
+
+ @Override
+ protected void configure() {
+
+ if (!requestResponseBindingExternalized) {
+
+ // request
+ bindFactory(HttpServletRequestReferencingFactory.class).to(HttpServletRequest.class)
+ .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
+
+ bindFactory(ReferencingFactory.referenceFactory())
+ .to(new GenericType<Ref<HttpServletRequest>>() {}).in(RequestScoped.class);
+
+ // response
+ bindFactory(HttpServletResponseReferencingFactory.class).to(HttpServletResponse.class)
+ .proxy(true).proxyForSameScope(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.referenceFactory())
+ .to(new GenericType<Ref<HttpServletResponse>>() {}).in(RequestScoped.class);
+ }
+
+ bindFactory(webConfig::getServletContext).to(ServletContext.class).in(Singleton.class);
+
+ final ServletConfig servletConfig = webConfig.getServletConfig();
+ if (webConfig.getConfigType() == WebConfig.ConfigType.ServletConfig) {
+ bindFactory(() -> servletConfig).to(ServletConfig.class).in(Singleton.class);
+
+ // @PersistenceUnit
+ final Enumeration initParams = servletConfig.getInitParameterNames();
+ while (initParams.hasMoreElements()) {
+ final String initParamName = (String) initParams.nextElement();
+
+ if (initParamName.startsWith(PersistenceUnitBinder.PERSISTENCE_UNIT_PREFIX)) {
+ install(new PersistenceUnitBinder(servletConfig));
+ break;
+ }
+ }
+ } else {
+ bindFactory(webConfig::getFilterConfig).to(FilterConfig.class).in(Singleton.class);
+ }
+
+ bindFactory(() -> webConfig).to(WebConfig.class).in(Singleton.class);
+
+ install(new ServiceFinderBinder<>(AsyncContextDelegateProvider.class, applicationProperties, RuntimeType.SERVER));
+ install(new ServiceFinderBinder<>(FilterUrlMappingsProvider.class, applicationProperties, RuntimeType.SERVER));
+ }
+ }
+
+ /**
+ * Jersey application handler.
+ */
+ final ApplicationHandler appHandler;
+
+ /**
+ * Jersey background task scheduler - used for scheduling request timeout event handling tasks.
+ */
+ final ScheduledExecutorService backgroundTaskScheduler;
+
+ /**
+ * Web component configuration.
+ */
+ final WebConfig webConfig;
+
+ /**
+ * If {@code true} and deployed as filter, the unmatched requests will be forwarded.
+ */
+ final boolean forwardOn404;
+
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR}.
+ * If {@code true} method {@link HttpServletResponse#setStatus} is used over {@link HttpServletResponse#sendError}.
+ */
+ final boolean configSetStatusOverSendError;
+
+ /**
+ * Asynchronous context delegate provider.
+ */
+ private final AsyncContextDelegateProvider asyncExtensionDelegate;
+
+ /**
+ * Flag whether query parameters should be kept as entity form params if a servlet filter consumes entity and
+ * Jersey has to retrieve form params from servlet request parameters.
+ */
+ private final boolean queryParamsAsFormParams;
+
+ /**
+ * Create and initialize new web component instance.
+ *
+ * @param webConfig we component configuration.
+ * @param resourceConfig Jersey application configuration.
+ * @throws ServletException in case the Jersey application cannot be created from the supplied
+ * resource configuration.
+ */
+ public WebComponent(final WebConfig webConfig, ResourceConfig resourceConfig) throws ServletException {
+
+ this.webConfig = webConfig;
+
+ if (resourceConfig == null) {
+ resourceConfig = createResourceConfig(webConfig);
+ }
+
+
+ final ServletContainerProvider[] allServletContainerProviders =
+ ServletContainerProviderFactory.getAllServletContainerProviders();
+
+ // SPI/extension hook to configure ResourceConfig
+ configure(resourceConfig, allServletContainerProviders);
+
+ boolean rrbExternalized = false;
+ RequestScopedInitializerProvider rsiProvider = null;
+
+ for (final ServletContainerProvider servletContainerProvider : allServletContainerProviders) {
+ if (servletContainerProvider instanceof ExtendedServletContainerProvider) {
+ final ExtendedServletContainerProvider extendedProvider =
+ (ExtendedServletContainerProvider) servletContainerProvider;
+
+ if (extendedProvider.bindsServletRequestResponse()) {
+ rrbExternalized = true;
+ }
+ if (rsiProvider == null) { // try to take the first non-null provider
+ rsiProvider = extendedProvider.getRequestScopedInitializerProvider();
+ }
+ }
+ }
+
+ requestScopedInitializer = rsiProvider != null ? rsiProvider : DEFAULT_REQUEST_SCOPE_INITIALIZER_PROVIDER;
+ requestResponseBindingExternalized = rrbExternalized;
+
+ final AbstractBinder webComponentBinder = new WebComponentBinder(resourceConfig.getProperties());
+ resourceConfig.register(webComponentBinder);
+
+ final Object locator = webConfig.getServletContext()
+ .getAttribute(ServletProperties.SERVICE_LOCATOR);
+
+ this.appHandler = new ApplicationHandler(resourceConfig, webComponentBinder, locator);
+
+ this.asyncExtensionDelegate = getAsyncExtensionDelegate();
+ this.forwardOn404 = webConfig.getConfigType() == WebConfig.ConfigType.FilterConfig
+ && resourceConfig.isProperty(ServletProperties.FILTER_FORWARD_ON_404);
+ this.queryParamsAsFormParams = !resourceConfig.isProperty(ServletProperties.QUERY_PARAMS_AS_FORM_PARAMS_DISABLED);
+ this.configSetStatusOverSendError = ServerProperties.getValue(resourceConfig.getProperties(),
+ ServerProperties.RESPONSE_SET_STATUS_OVER_SEND_ERROR, false, Boolean.class);
+ this.backgroundTaskScheduler = appHandler.getInjectionManager()
+ .getInstance(ScheduledExecutorService.class, BackgroundSchedulerLiteral.INSTANCE);
+ }
+
+ /**
+ * Dispatch client requests to a resource class.
+ *
+ * @param baseUri the base URI of the request.
+ * @param requestUri the URI of the request.
+ * @param servletRequest the {@link javax.servlet.http.HttpServletRequest} object that
+ * contains the request the client made to
+ * the Web component.
+ * @param servletResponse the {@link javax.servlet.http.HttpServletResponse} object that
+ * contains the response the Web component returns
+ * to the client.
+ * @return lazily initialized response status code {@link Value value provider}. If not resolved in the moment of call to
+ * {@link Value#get()}, {@code -1} is returned.
+ * @throws java.io.IOException if an input or output error occurs
+ * while the Web component is handling the
+ * HTTP request.
+ * @throws javax.servlet.ServletException if the HTTP request cannot be handled.
+ */
+ public Value<Integer> service(
+ final URI baseUri,
+ final URI requestUri,
+ final HttpServletRequest servletRequest,
+ final HttpServletResponse servletResponse) throws ServletException, IOException {
+ final ResponseWriter responseWriter = serviceImpl(baseUri, requestUri, servletRequest, servletResponse);
+ return Values.lazy(new Value<Integer>() {
+ @Override
+ public Integer get() {
+ return responseWriter.responseContextResolved() ? responseWriter.getResponseStatus() : -1;
+ }
+ });
+ }
+
+ /**
+ * Dispatch client requests to a resource class.
+ *
+ * @param baseUri the base URI of the request.
+ * @param requestUri the URI of the request.
+ * @param servletRequest the {@link javax.servlet.http.HttpServletRequest} object that
+ * contains the request the client made to
+ * the Web component.
+ * @param servletResponse the {@link javax.servlet.http.HttpServletResponse} object that
+ * contains the response the Web component returns
+ * to the client.
+ * @return returns {@link ResponseWriter}, Servlet's {@link org.glassfish.jersey.server.spi.ContainerResponseWriter}
+ * implementation, into which processed request response was written to.
+ * @throws java.io.IOException if an input or output error occurs
+ * while the Web component is handling the
+ * HTTP request.
+ * @throws javax.servlet.ServletException if the HTTP request cannot be handled.
+ */
+ /* package */ ResponseWriter serviceImpl(
+ final URI baseUri,
+ final URI requestUri,
+ final HttpServletRequest servletRequest,
+ final HttpServletResponse servletResponse) throws ServletException, IOException {
+
+ final ResponseWriter responseWriter = new ResponseWriter(
+ forwardOn404,
+ configSetStatusOverSendError,
+ servletResponse,
+ asyncExtensionDelegate.createDelegate(servletRequest, servletResponse),
+ backgroundTaskScheduler);
+
+ try {
+ final ContainerRequest requestContext = new ContainerRequest(baseUri, requestUri, servletRequest.getMethod(),
+ getSecurityContext(servletRequest), new ServletPropertiesDelegate(servletRequest));
+
+ initContainerRequest(requestContext, servletRequest, servletResponse, responseWriter);
+
+ appHandler.handle(requestContext);
+ } catch (final HeaderValueException hve) {
+ if (LOGGER.isLoggable(Level.FINE)) {
+ LOGGER.log(Level.FINE, LocalizationMessages.HEADER_VALUE_READ_FAILED(), hve);
+ }
+
+ final Response.Status status = Response.Status.BAD_REQUEST;
+
+ if (configSetStatusOverSendError) {
+ servletResponse.reset();
+ //noinspection deprecation
+ servletResponse.setStatus(status.getStatusCode(), status.getReasonPhrase());
+ } else {
+ servletResponse.sendError(status.getStatusCode(), status.getReasonPhrase());
+ }
+ } catch (final Exception e) {
+ throw new ServletException(e);
+ }
+ return responseWriter;
+ }
+
+ /**
+ * Initialize {@code ContainerRequest} instance to used used to handle {@code servletRequest}.
+ */
+ private void initContainerRequest(
+ final ContainerRequest requestContext,
+ final HttpServletRequest servletRequest,
+ final HttpServletResponse servletResponse,
+ final ResponseWriter responseWriter) throws IOException {
+
+ requestContext.setEntityStream(servletRequest.getInputStream());
+ requestContext.setRequestScopedInitializer(requestScopedInitializer.get(new RequestContextProvider() {
+ @Override
+ public HttpServletRequest getHttpServletRequest() {
+ return servletRequest;
+ }
+ @Override
+ public HttpServletResponse getHttpServletResponse() {
+ return servletResponse;
+ }
+ }));
+ requestContext.setWriter(responseWriter);
+
+ addRequestHeaders(servletRequest, requestContext);
+ // Check if any servlet filters have consumed a request entity
+ // of the media type application/x-www-form-urlencoded
+ // This can happen if a filter calls request.getParameter(...)
+ filterFormParameters(servletRequest, requestContext);
+ }
+
+ /**
+ * Get default {@link javax.ws.rs.core.SecurityContext} for given {@code request}.
+ *
+ * @param request http servlet request to create a security context for.
+ * @return a non-null security context instance.
+ */
+ private static SecurityContext getSecurityContext(final HttpServletRequest request) {
+ return new SecurityContext() {
+
+ @Override
+ public Principal getUserPrincipal() {
+ return request.getUserPrincipal();
+ }
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return request.isUserInRole(role);
+ }
+
+ @Override
+ public boolean isSecure() {
+ return request.isSecure();
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return request.getAuthType();
+ }
+ };
+ }
+
+ /**
+ * Create a {@link ResourceConfig} instance from given {@link WebConfig}.
+ *
+ * @param config web config to create resource config from.
+ * @return resource config instance.
+ * @throws ServletException if an error has occurred.
+ */
+ private static ResourceConfig createResourceConfig(final WebConfig config) throws ServletException {
+ final ServletContext servletContext = config.getServletContext();
+
+ // check if ResourceConfig has already been created, if so use it
+ ResourceConfig resourceConfig = Utils.retrieve(config.getServletContext(), config.getName());
+ if (resourceConfig != null) {
+ return resourceConfig;
+ }
+
+ final Map<String, Object> initParams = getInitParams(config);
+ final Map<String, Object> contextParams = Utils.getContextParams(servletContext);
+
+ // check if the JAX-RS application config class property is present
+ final String jaxrsApplicationClassName = config.getInitParameter(ServletProperties.JAXRS_APPLICATION_CLASS);
+
+ if (jaxrsApplicationClassName == null) {
+ // If no resource config class property is present, create default config
+ resourceConfig = new ResourceConfig().addProperties(initParams).addProperties(contextParams);
+
+ final String webApp = config.getInitParameter(ServletProperties.PROVIDER_WEB_APP);
+ if (webApp != null && !"false".equals(webApp)) {
+ resourceConfig.registerFinder(new WebAppResourcesScanner(servletContext));
+ }
+ return resourceConfig;
+ }
+
+ try {
+ final Class<? extends javax.ws.rs.core.Application> jaxrsApplicationClass = AccessController.doPrivileged(
+ ReflectionHelper.<javax.ws.rs.core.Application>classForNameWithExceptionPEA(jaxrsApplicationClassName)
+ );
+
+ if (javax.ws.rs.core.Application.class.isAssignableFrom(jaxrsApplicationClass)) {
+ return ResourceConfig.forApplicationClass(jaxrsApplicationClass)
+ .addProperties(initParams).addProperties(contextParams);
+ } else {
+ throw new ServletException(LocalizationMessages.RESOURCE_CONFIG_PARENT_CLASS_INVALID(
+ jaxrsApplicationClassName, javax.ws.rs.core.Application.class));
+ }
+ } catch (final PrivilegedActionException e) {
+ throw new ServletException(
+ LocalizationMessages.RESOURCE_CONFIG_UNABLE_TO_LOAD(jaxrsApplicationClassName), e.getCause());
+ } catch (final ClassNotFoundException e) {
+ throw new ServletException(LocalizationMessages.RESOURCE_CONFIG_UNABLE_TO_LOAD(jaxrsApplicationClassName), e);
+ }
+ }
+
+ /**
+ * SPI/extension hook to configure ResourceConfig.
+ *
+ * @param resourceConfig Jersey application configuration.
+ * @throws ServletException if an error has occurred.
+ */
+ private void configure(final ResourceConfig resourceConfig,
+ final ServletContainerProvider[] allServletContainerProviders) throws ServletException {
+
+ for (final ServletContainerProvider servletContainerProvider : allServletContainerProviders) {
+ servletContainerProvider.configure(resourceConfig);
+ }
+ }
+
+ /**
+ * Copy request headers present in {@code request} into {@code requestContext} ignoring {@code null} values.
+ *
+ * @param request http servlet request to copy headers from.
+ * @param requestContext container request to copy headers to.
+ */
+ @SuppressWarnings("unchecked")
+ private void addRequestHeaders(final HttpServletRequest request, final ContainerRequest requestContext) {
+ final Enumeration<String> names = request.getHeaderNames();
+ while (names.hasMoreElements()) {
+ final String name = names.nextElement();
+
+ final Enumeration<String> values = request.getHeaders(name);
+ while (values.hasMoreElements()) {
+ final String value = values.nextElement();
+ if (value != null) { // filter out null values
+ requestContext.header(name, value);
+ }
+ }
+ }
+ }
+
+ /**
+ * Extract init params from {@link WebConfig}.
+ *
+ * @param webConfig actual servlet context.
+ * @return map representing current init parameters.
+ */
+ private static Map<String, Object> getInitParams(final WebConfig webConfig) {
+ final Map<String, Object> props = new HashMap<>();
+ final Enumeration names = webConfig.getInitParameterNames();
+ while (names.hasMoreElements()) {
+ final String name = (String) names.nextElement();
+ props.put(name, webConfig.getInitParameter(name));
+ }
+ return props;
+ }
+
+ /**
+ * Extract parameters contained in {@link HttpServletRequest servlet request} and put them into
+ * {@link ContainerRequest container request} under
+ * {@value org.glassfish.jersey.server.internal.InternalServerProperties#FORM_DECODED_PROPERTY} property (as {@link Form}
+ * instance).
+ *
+ * @param servletRequest http servlet request to extract params from.
+ * @param containerRequest container request to put {@link Form} property to.
+ */
+ private void filterFormParameters(final HttpServletRequest servletRequest, final ContainerRequest containerRequest) {
+ if (MediaTypes.typeEqual(MediaType.APPLICATION_FORM_URLENCODED_TYPE, containerRequest.getMediaType())
+ && !containerRequest.hasEntity()) {
+ final Form form = new Form();
+ final Enumeration parameterNames = servletRequest.getParameterNames();
+
+ final String queryString = servletRequest.getQueryString();
+ final List<String> queryParams = queryString != null ? getDecodedQueryParamList(queryString)
+ : Collections.<String>emptyList();
+
+ final boolean keepQueryParams = queryParamsAsFormParams || queryParams.isEmpty();
+ final MultivaluedMap<String, String> formMap = form.asMap();
+
+ while (parameterNames.hasMoreElements()) {
+ final String name = (String) parameterNames.nextElement();
+ final List<String> values = Arrays.asList(servletRequest.getParameterValues(name));
+
+ formMap.put(name, keepQueryParams ? values : filterQueryParams(name, values, queryParams));
+ }
+
+ if (!formMap.isEmpty()) {
+ containerRequest.setProperty(InternalServerProperties.FORM_DECODED_PROPERTY, form);
+
+ if (LOGGER.isLoggable(Level.WARNING)) {
+ LOGGER.log(Level.WARNING, LocalizationMessages.FORM_PARAM_CONSUMED(containerRequest.getRequestUri()));
+ }
+ }
+ }
+ }
+
+ private List<String> getDecodedQueryParamList(final String queryString) {
+ final List<String> params = new ArrayList<>();
+ for (final String param : queryString.split("&")) {
+ params.add(UriComponent.decode(param, UriComponent.Type.QUERY_PARAM));
+ }
+ return params;
+ }
+
+ /**
+ * From given list of values remove values that represents values of query params of the same name as the processed form
+ * parameter.
+ *
+ * @param name name of form/query parameter.
+ * @param values values of form/query parameter.
+ * @param params collection of unprocessed query parameters.
+ * @return list of form param values for given name without values of query param of the same name.
+ */
+ private List<String> filterQueryParams(final String name, final List<String> values, final Collection<String> params) {
+ return values.stream()
+ .filter(s -> !params.remove(name + "=" + s) && !params.remove(name + "[]=" + s))
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Get {@link ApplicationHandler} used by this web component.
+ *
+ * @return The application handler
+ */
+ public ApplicationHandler getAppHandler() {
+ return appHandler;
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebConfig.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebConfig.java
new file mode 100644
index 0000000..bb469c6
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebConfig.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.util.Enumeration;
+
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+
+/**
+ * The Web configuration for accessing initialization parameters of a Web
+ * component and the {@link ServletContext}.
+ *
+ * @author Paul Sandoz
+ */
+public interface WebConfig {
+
+ /**
+ * The web configuration type.
+ */
+ public static enum ConfigType {
+ /**
+ * A configuration type of servlet configuration.
+ */
+ ServletConfig,
+ /**
+ * A configuration type of filter configuration.
+ */
+ FilterConfig
+ }
+
+ /**
+ * Get the configuration type of this config.
+ *
+ * @return the configuration type.
+ */
+ ConfigType getConfigType();
+
+ /**
+ * Get the corresponding ServletConfig if this WebConfig represents a {@link ServletConfig}
+ *
+ * @return servlet config or null
+ */
+ ServletConfig getServletConfig();
+
+ /**
+ * Get the corresponding FilterConfig if this WebConfig represents a {@link FilterConfig}
+ *
+ * @return filter config or null
+ */
+ FilterConfig getFilterConfig();
+
+ /**
+ * Get the name of the Web component.
+ *
+ * @return the name of the Web component.
+ */
+ String getName();
+
+ /**
+ * Get an initialization parameter.
+ *
+ * @param name the parameter name.
+ * @return the parameter value, or null if the parameter is not present.
+ */
+ String getInitParameter(String name);
+
+ /**
+ * Get the enumeration of initialization parameter names.
+ *
+ * @return the enumeration of initialization parameter names.
+ */
+ Enumeration getInitParameterNames();
+
+ /**
+ * Get the {@link ServletContext}.
+ *
+ * @return the {@link ServletContext}.
+ */
+ ServletContext getServletContext();
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebFilterConfig.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebFilterConfig.java
new file mode 100644
index 0000000..d375b85
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebFilterConfig.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.util.Enumeration;
+
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+
+/**
+ * A filter based web config. Delegates all invocations to the filter
+ * configuration from the servlet api.
+ *
+ * @author Paul Sandoz
+ * @author Guilherme Silveira
+ */
+public final class WebFilterConfig implements WebConfig {
+
+ private final FilterConfig filterConfig;
+
+ public WebFilterConfig(final FilterConfig filterConfig) {
+ this.filterConfig = filterConfig;
+ }
+
+ @Override
+ public WebConfig.ConfigType getConfigType() {
+ return WebConfig.ConfigType.FilterConfig;
+ }
+
+ @Override
+ public ServletConfig getServletConfig() {
+ return null;
+ }
+
+ @Override
+ public FilterConfig getFilterConfig() {
+ return filterConfig;
+ }
+
+ @Override
+ public String getName() {
+ return filterConfig.getFilterName();
+ }
+
+ @Override
+ public String getInitParameter(final String name) {
+ return filterConfig.getInitParameter(name);
+ }
+
+ @Override
+ public Enumeration getInitParameterNames() {
+ return filterConfig.getInitParameterNames();
+ }
+
+ @Override
+ public ServletContext getServletContext() {
+ return filterConfig.getServletContext();
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebServletConfig.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebServletConfig.java
new file mode 100644
index 0000000..5c2a7a7
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/WebServletConfig.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet;
+
+import java.util.Enumeration;
+
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+
+/**
+ * A servlet based web config. Delegates all invocations to the servlet
+ * configuration from the servlet api.
+ *
+ * @author Paul Sandoz
+ * @author guilherme silveira
+ */
+public final class WebServletConfig implements WebConfig {
+
+ private final ServletContainer servlet;
+
+ public WebServletConfig(final ServletContainer servlet) {
+ this.servlet = servlet;
+ }
+
+ @Override
+ public WebConfig.ConfigType getConfigType() {
+ return WebConfig.ConfigType.ServletConfig;
+ }
+
+ @Override
+ public ServletConfig getServletConfig() {
+ return servlet.getServletConfig();
+ }
+
+ @Override
+ public FilterConfig getFilterConfig() {
+ return null;
+ }
+
+ @Override
+ public String getName() {
+ return servlet.getServletName();
+ }
+
+ @Override
+ public String getInitParameter(final String name) {
+ return servlet.getInitParameter(name);
+ }
+
+ @Override
+ public Enumeration getInitParameterNames() {
+ return servlet.getInitParameterNames();
+ }
+
+ @Override
+ public ServletContext getServletContext() {
+ return servlet.getServletContext();
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/PersistenceUnitBinder.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/PersistenceUnitBinder.java
new file mode 100644
index 0000000..f1795c6
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/PersistenceUnitBinder.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.lang.reflect.Proxy;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.ws.rs.core.GenericType;
+
+import javax.inject.Singleton;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.PersistenceUnit;
+import javax.servlet.ServletConfig;
+
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.Injectee;
+import org.glassfish.jersey.internal.inject.InjectionResolver;
+import org.glassfish.jersey.server.ContainerException;
+
+/**
+ * {@link PersistenceUnit Persistence unit} injection binder.
+ *
+ * @author Michal Gajdos
+ */
+public class PersistenceUnitBinder extends AbstractBinder {
+
+ private final ServletConfig servletConfig;
+
+ /**
+ * Prefix of the persistence unit init param.
+ */
+ public static final String PERSISTENCE_UNIT_PREFIX = "unit:";
+
+ /**
+ * Creates a new binder for {@link PersistenceUnitInjectionResolver}.
+ *
+ * @param servletConfig servlet config to find persistence units.
+ */
+ public PersistenceUnitBinder(ServletConfig servletConfig) {
+ this.servletConfig = servletConfig;
+ }
+
+ @Singleton
+ private static class PersistenceUnitInjectionResolver implements InjectionResolver<PersistenceUnit> {
+
+ private final Map<String, String> persistenceUnits = new HashMap<>();
+
+ private PersistenceUnitInjectionResolver(ServletConfig servletConfig) {
+ for (final Enumeration parameterNames = servletConfig.getInitParameterNames(); parameterNames.hasMoreElements(); ) {
+ final String key = (String) parameterNames.nextElement();
+
+ if (key.startsWith(PERSISTENCE_UNIT_PREFIX)) {
+ persistenceUnits.put(key.substring(PERSISTENCE_UNIT_PREFIX.length()),
+ "java:comp/env/" + servletConfig.getInitParameter(key));
+ }
+ }
+ }
+
+ @Override
+ public Object resolve(Injectee injectee) {
+ if (!injectee.getRequiredType().equals(EntityManagerFactory.class)) {
+ return null;
+ }
+
+ final PersistenceUnit annotation = injectee.getParent().getAnnotation(PersistenceUnit.class);
+ final String unitName = annotation.unitName();
+
+ if (!persistenceUnits.containsKey(unitName)) {
+ throw new ContainerException(LocalizationMessages.PERSISTENCE_UNIT_NOT_CONFIGURED(unitName));
+ }
+
+ return Proxy.newProxyInstance(
+ this.getClass().getClassLoader(),
+ new Class[] {EntityManagerFactory.class},
+ new ThreadLocalNamedInvoker<EntityManagerFactory>(persistenceUnits.get(unitName)));
+ }
+
+ @Override
+ public boolean isConstructorParameterIndicator() {
+ return false;
+ }
+
+ @Override
+ public boolean isMethodParameterIndicator() {
+ return false;
+ }
+
+ @Override
+ public Class<PersistenceUnit> getAnnotation() {
+ return PersistenceUnit.class;
+ }
+ }
+
+ @Override
+ protected void configure() {
+ bind(new PersistenceUnitInjectionResolver(servletConfig))
+ .to(new GenericType<InjectionResolver<PersistenceUnit>>() {});
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ResponseWriter.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ResponseWriter.java
new file mode 100644
index 0000000..b96ebb7
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ResponseWriter.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.internal.JerseyRequestTimeoutHandler;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+import org.glassfish.jersey.servlet.spi.AsyncContextDelegate;
+
+/**
+ * An internal implementation of {@link ContainerResponseWriter} for Servlet containers.
+ * The writer depends on provided {@link AsyncContextDelegate} to support async functionality.
+ *
+ * @author Paul Sandoz
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Martin Matula
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class ResponseWriter implements ContainerResponseWriter {
+
+ private static final Logger LOGGER = Logger.getLogger(ResponseWriter.class.getName());
+
+ private final HttpServletResponse response;
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.servlet.ServletProperties#FILTER_FORWARD_ON_404}.
+ */
+ private final boolean useSetStatusOn404;
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR}.
+ * If {@code true} method {@link HttpServletResponse#setStatus} is used over {@link HttpServletResponse#sendError}.
+ */
+ private final boolean configSetStatusOverSendError;
+ private final CompletableFuture<ContainerResponse> responseContext;
+ private final AsyncContextDelegate asyncExt;
+
+ private final JerseyRequestTimeoutHandler requestTimeoutHandler;
+
+ /**
+ * Creates a new instance to write a single Jersey response.
+ *
+ * @param useSetStatusOn404 true if status should be written explicitly when 404 is returned
+ * @param configSetStatusOverSendError if {@code true} method {@link HttpServletResponse#setStatus} is used over
+ * {@link HttpServletResponse#sendError}
+ * @param response original HttpResponseRequest
+ * @param asyncExt delegate to use for async features implementation
+ * @param timeoutTaskExecutor Jersey runtime executor used for background execution of timeout
+ * handling tasks.
+ */
+ public ResponseWriter(final boolean useSetStatusOn404,
+ final boolean configSetStatusOverSendError,
+ final HttpServletResponse response,
+ final AsyncContextDelegate asyncExt,
+ final ScheduledExecutorService timeoutTaskExecutor) {
+ this.useSetStatusOn404 = useSetStatusOn404;
+ this.configSetStatusOverSendError = configSetStatusOverSendError;
+ this.response = response;
+ this.asyncExt = asyncExt;
+ this.responseContext = new CompletableFuture<>();
+
+ this.requestTimeoutHandler = new JerseyRequestTimeoutHandler(this, timeoutTaskExecutor);
+ }
+
+ @Override
+ public boolean suspend(final long timeOut, final TimeUnit timeUnit, final TimeoutHandler timeoutHandler) {
+ try {
+ // Suspend the servlet.
+ asyncExt.suspend();
+ } catch (final IllegalStateException ex) {
+ LOGGER.log(Level.WARNING, LocalizationMessages.SERVLET_REQUEST_SUSPEND_FAILED(), ex);
+ return false;
+ }
+ // Suspend the internal request timeout handler.
+ return requestTimeoutHandler.suspend(timeOut, timeUnit, timeoutHandler);
+ }
+
+ @Override
+ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit) throws IllegalStateException {
+ requestTimeoutHandler.setSuspendTimeout(timeOut, timeUnit);
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(final long contentLength, final ContainerResponse responseContext)
+ throws ContainerException {
+ this.responseContext.complete(responseContext);
+
+ // first set the content length, so that if headers have an explicit value, it takes precedence over this one
+ if (responseContext.hasEntity() && contentLength != -1 && contentLength < Integer.MAX_VALUE) {
+ response.setContentLength((int) contentLength);
+ }
+ // Note that the writing of headers MUST be performed before
+ // the invocation of sendError as on some Servlet implementations
+ // modification of the response headers will have no effect
+ // after the invocation of sendError.
+ final MultivaluedMap<String, String> headers = getResponseContext().getStringHeaders();
+ for (final Map.Entry<String, List<String>> e : headers.entrySet()) {
+ final Iterator<String> it = e.getValue().iterator();
+ if (!it.hasNext()) {
+ continue;
+ }
+ final String header = e.getKey();
+ if (response.containsHeader(header)) {
+ // replace any headers previously set with values from Jersey container response.
+ response.setHeader(header, it.next());
+ }
+
+ while (it.hasNext()) {
+ response.addHeader(header, it.next());
+ }
+ }
+
+ final String reasonPhrase = responseContext.getStatusInfo().getReasonPhrase();
+ if (reasonPhrase != null) {
+ response.setStatus(responseContext.getStatus(), reasonPhrase);
+ } else {
+ response.setStatus(responseContext.getStatus());
+ }
+
+ if (!responseContext.hasEntity()) {
+ return null;
+ } else {
+ try {
+ final OutputStream outputStream = response.getOutputStream();
+
+ // delegating output stream prevents closing the underlying servlet output stream,
+ // so that any Servlet filters in the chain can still write to the response after us.
+ return new NonCloseableOutputStreamWrapper(outputStream);
+ } catch (final IOException e) {
+ throw new ContainerException(e);
+ }
+ }
+ }
+
+ @Override
+ public void commit() {
+ try {
+ callSendError();
+ } finally {
+ requestTimeoutHandler.close();
+ asyncExt.complete();
+ }
+ }
+
+ /**
+ * According to configuration and response processing status it calls {@link HttpServletResponse#sendError(int, String)} over
+ * common {@link HttpServletResponse#setStatus(int)}.
+ */
+ private void callSendError() {
+ // call HttpServletResponse.sendError in case:
+ // - property ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR == false (default)
+ // - response NOT yet committed
+ // - response entity NOT set
+ // - response status code is 4xx or 5xx
+ // plus in case of Jersey as a Filter (JaaF):
+ // - response status code is 404 (Not Found)
+ // - property ServletProperties#FILTER_FORWARD_ON_404 == false (default)
+ if (!configSetStatusOverSendError && !response.isCommitted()) {
+ final ContainerResponse responseContext = getResponseContext();
+ final boolean hasEntity = responseContext.hasEntity();
+ final Response.StatusType status = responseContext.getStatusInfo();
+ if (!hasEntity && status != null && status.getStatusCode() >= 400
+ && !(useSetStatusOn404 && status == Response.Status.NOT_FOUND)) {
+ final String reason = status.getReasonPhrase();
+ try {
+ if (reason == null || reason.isEmpty()) {
+ response.sendError(status.getStatusCode());
+ } else {
+ response.sendError(status.getStatusCode(), reason);
+ }
+ } catch (final IOException ex) {
+ throw new ContainerException(
+ LocalizationMessages.EXCEPTION_SENDING_ERROR_RESPONSE(status, reason != null ? reason : "--"),
+ ex);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void failure(final Throwable error) {
+ try {
+ if (!response.isCommitted()) {
+ try {
+ if (configSetStatusOverSendError) {
+ response.reset();
+ //noinspection deprecation
+ response.setStatus(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), "Request failed.");
+ } else {
+ response.sendError(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), "Request failed.");
+ }
+ } catch (final IllegalStateException ex) {
+ // a race condition externally committing the response can still occur...
+ LOGGER.log(Level.FINER, "Unable to reset failed response.", ex);
+ } catch (final IOException ex) {
+ throw new ContainerException(LocalizationMessages.EXCEPTION_SENDING_ERROR_RESPONSE(
+ Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), "Request failed."), ex);
+ } finally {
+ asyncExt.complete();
+ }
+ }
+ } finally {
+ requestTimeoutHandler.close();
+ rethrow(error);
+ }
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return true;
+ }
+
+ /**
+ * Rethrow the original exception as required by JAX-RS, 3.3.4
+ *
+ * @param error throwable to be re-thrown
+ */
+ private void rethrow(final Throwable error) {
+ if (error instanceof RuntimeException) {
+ throw (RuntimeException) error;
+ } else {
+ throw new ContainerException(error);
+ }
+ }
+
+ /**
+ * Provides response status captured when
+ * {@link #writeResponseStatusAndHeaders(long, org.glassfish.jersey.server.ContainerResponse)} has been invoked.
+ * The method will block if the write method has not been called yet.
+ *
+ * @return response status
+ */
+ public int getResponseStatus() {
+ return getResponseContext().getStatus();
+ }
+
+ public boolean responseContextResolved() {
+ return responseContext.isDone();
+ }
+
+ public ContainerResponse getResponseContext() {
+ try {
+ return responseContext.get();
+ } catch (InterruptedException | ExecutionException ex) {
+ throw new ContainerException(ex);
+ }
+ }
+
+ private static class NonCloseableOutputStreamWrapper extends OutputStream {
+
+ private final OutputStream delegate;
+
+ public NonCloseableOutputStreamWrapper(final OutputStream delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void write(final int b) throws IOException {
+ delegate.write(b);
+ }
+
+ @Override
+ public void write(final byte[] b) throws IOException {
+ delegate.write(b);
+ }
+
+ @Override
+ public void write(final byte[] b, final int off, final int len) throws IOException {
+ delegate.write(b, off, len);
+ }
+
+ @Override
+ public void flush() throws IOException {
+ delegate.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ // do not close - let the servlet container close the stream
+ }
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ServletContainerProviderFactory.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ServletContainerProviderFactory.java
new file mode 100644
index 0000000..8dbeb80
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ServletContainerProviderFactory.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import org.glassfish.jersey.internal.ServiceFinder;
+import org.glassfish.jersey.servlet.internal.spi.ServletContainerProvider;
+
+/**
+ * Factory class to get all "registered" implementations of {@link ServletContainerProvider}.
+ * Mentioned implementation classes are registered by {@code META-INF/services}.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @since 2.1
+ */
+public final class ServletContainerProviderFactory {
+
+ private ServletContainerProviderFactory() {
+ }
+
+ /**
+ * Returns array of all "registered" implementations of {@link ServletContainerProvider}.
+ *
+ * @return Array of registered providers. Never returns {@code null}.
+ * If there is no implementation registered empty array is returned.
+ */
+ public static ServletContainerProvider[] getAllServletContainerProviders() {
+ // TODO Instances of ServletContainerProvider could be cached, maybe. ???
+ // TODO Check if META-INF/services lookup is enabled. ???
+ return ServiceFinder.find(ServletContainerProvider.class).toArray();
+ }
+
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvoker.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvoker.java
new file mode 100644
index 0000000..9ef4724
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvoker.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * A proxy invocation handler that delegates all methods to a thread local instance.
+ *
+ * @author Paul Sandoz
+ */
+public class ThreadLocalInvoker<T> implements InvocationHandler {
+
+ private ThreadLocal<T> threadLocalInstance = new ThreadLocal<>();
+
+ public void set(final T threadLocalInstance) {
+ this.threadLocalInstance.set(threadLocalInstance);
+ }
+
+ public T get() {
+ return this.threadLocalInstance.get();
+ }
+
+ @Override
+ public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
+ if (threadLocalInstance.get() == null) {
+ throw new IllegalStateException(LocalizationMessages.PERSISTENCE_UNIT_NOT_CONFIGURED(proxy.getClass()));
+ }
+
+ try {
+ return method.invoke(threadLocalInstance.get(), args);
+ } catch (final IllegalAccessException ex) {
+ throw new IllegalStateException(ex);
+ } catch (final InvocationTargetException ex) {
+ throw ex.getTargetException();
+ }
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalNamedInvoker.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalNamedInvoker.java
new file mode 100644
index 0000000..f8acc93
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ThreadLocalNamedInvoker.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.lang.reflect.Method;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+
+/**
+ * A proxy invocation handler that delegates all methods to a thread local instance from JNDI.
+ *
+ * @author Paul Sandoz
+ */
+public class ThreadLocalNamedInvoker<T> extends ThreadLocalInvoker<T> {
+
+ private final String name;
+
+ /**
+ * Create an instance.
+ *
+ * @param name the JNDI name at which an instance of T can be found.
+ */
+ public ThreadLocalNamedInvoker(final String name) {
+ this.name = name;
+ }
+
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ // if no instance yet exists for the current thread then look one up and stash it
+ if (this.get() == null) {
+ Context ctx = new InitialContext();
+ T t = (T) ctx.lookup(name);
+ this.set(t);
+ }
+ return super.invoke(proxy, method, args);
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/Utils.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/Utils.java
new file mode 100644
index 0000000..c125116
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/Utils.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.servlet.ServletContext;
+
+import org.glassfish.jersey.server.ResourceConfig;
+
+/**
+ * Utility class.
+ *
+ * @author Michal Gajdos
+ */
+public final class Utils {
+
+ /**
+ * Internal {@link javax.servlet.ServletContext servlet context} attribute name under which an instance of
+ * {@link org.glassfish.jersey.server.ResourceConfig resource config} can be stored. The instance is later used to initialize
+ * servlet in {@link org.glassfish.jersey.servlet.WebConfig} instead of creating a new one.
+ */
+ private static final String RESOURCE_CONFIG = "jersey.config.servlet.internal.resourceConfig";
+
+ /**
+ * Store {@link org.glassfish.jersey.server.ResourceConfig resource config} as an attribute of given
+ * {@link javax.servlet.ServletContext servlet context}. If {@code config} is {@code null} then the previously stored value
+ * (if any) is removed. The {@code configName} is used as an attribute name suffix.
+ *
+ * @param config resource config to be stored.
+ * @param context servlet context to store the config in.
+ * @param configName name or id of the resource config.
+ */
+ public static void store(final ResourceConfig config, final ServletContext context, final String configName) {
+ final String attributeName = RESOURCE_CONFIG + "_" + configName;
+ context.setAttribute(attributeName, config);
+ }
+
+ /**
+ * Load {@link org.glassfish.jersey.server.ResourceConfig resource config} from given
+ * {@link javax.servlet.ServletContext servlet context}. If found then the resource config is also removed from servlet
+ * context. The {@code configName} is used as an attribute name suffix.
+ *
+ * @param context servlet context to load resource config from.
+ * @param configName name or id of the resource config.
+ * @return previously stored resource config or {@code null} if no resource config has been stored.
+ */
+ public static ResourceConfig retrieve(final ServletContext context, final String configName) {
+ final String attributeName = RESOURCE_CONFIG + "_" + configName;
+ final ResourceConfig config = (ResourceConfig) context.getAttribute(attributeName);
+ context.removeAttribute(attributeName);
+ return config;
+ }
+
+ /**
+ * Extract context params from {@link ServletContext}.
+ *
+ * @param servletContext actual servlet context.
+ * @return map representing current context parameters.
+ */
+ public static Map<String, Object> getContextParams(final ServletContext servletContext) {
+ final Map<String, Object> props = new HashMap<>();
+ final Enumeration names = servletContext.getAttributeNames();
+ while (names.hasMoreElements()) {
+ final String name = (String) names.nextElement();
+ props.put(name, servletContext.getAttribute(name));
+ }
+ return props;
+ }
+
+ /**
+ * Prevents instantiation.
+ */
+ private Utils() {
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/package-info.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/package-info.java
new file mode 100644
index 0000000..6f5d32e
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey internal Servlet API.
+ */
+package org.glassfish.jersey.servlet.internal;
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ExtendedServletContainerProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ExtendedServletContainerProvider.java
new file mode 100644
index 0000000..f9fa19b
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ExtendedServletContainerProvider.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal.spi;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.RequestScopedInitializer;
+
+/**
+ * Implementations could provide their own {@link HttpServletRequest} and {@link HttpServletResponse}
+ * binding implementation in HK2 locator and also an implementation of {@link RequestScopedInitializer}
+ * that is used to set actual request/response references in injection manager within each request.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @since 2.21
+ */
+public interface ExtendedServletContainerProvider extends ServletContainerProvider {
+
+ /**
+ * Give me a {@link RequestScopedInitializerProvider} instance, that will be utilized
+ * at runtime to set the actual HTTP Servlet request and response.
+ *
+ * The provider returned will be used at runtime for every and each incoming request
+ * so that the actual request/response instances could be made accessible
+ * from Jersey injection manager.
+ *
+ * @return request scoped initializer provider.
+ */
+ public RequestScopedInitializerProvider getRequestScopedInitializerProvider();
+
+ /**
+ * Used by Jersey runtime to tell if the extension covers HTTP Servlet request response
+ * handling with respect to underlying injection manager.
+ *
+ * Return {@code true}, if your implementation configures HK2 bindings
+ * for {@link HttpServletRequest} and {@link HttpServletResponse}
+ * in {@link #configure(ResourceConfig)} method
+ * and also provides a {@link RequestScopedInitializer} implementation
+ * via {@link #getRequestScopedInitializerProvider()}.
+ *
+ * @return {@code true} if the extension fully covers HTTP request/response handling.
+ */
+ public boolean bindsServletRequestResponse();
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/NoOpServletContainerProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/NoOpServletContainerProvider.java
new file mode 100644
index 0000000..d4147d8
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/NoOpServletContainerProvider.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal.spi;
+
+import java.lang.reflect.Type;
+import java.util.Set;
+
+import javax.ws.rs.core.GenericType;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.server.ResourceConfig;
+
+/**
+ * Basic {@link ExtendedServletContainerProvider} that provides
+ * dummy no-op method implementation. It should be convenient to extend if you only need to implement
+ * a subset of the original SPI methods.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public class NoOpServletContainerProvider implements ExtendedServletContainerProvider {
+
+ public final Type HTTP_SERVLET_REQUEST_TYPE = (new GenericType<Ref<HttpServletRequest>>() { }).getType();
+ public final Type HTTP_SERVLET_RESPONSE_TYPE = (new GenericType<Ref<HttpServletResponse>>() { }).getType();
+
+ @Override
+ public void preInit(final ServletContext servletContext, final Set<Class<?>> classes) throws ServletException {
+ // no-op
+ }
+
+ @Override
+ public void postInit(
+ final ServletContext servletContext, final Set<Class<?>> classes, final Set<String> servletNames) {
+ // no-op
+ }
+
+ @Override
+ public void onRegister(
+ final ServletContext servletContext, final Set<String> servletNames) throws ServletException {
+ // no-op
+ }
+
+ @Override
+ public void configure(final ResourceConfig resourceConfig) throws ServletException {
+ // no-op
+ }
+
+ @Override
+ public boolean bindsServletRequestResponse() {
+ return false;
+ }
+
+ @Override
+ public RequestScopedInitializerProvider getRequestScopedInitializerProvider() {
+ return null;
+ }
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestContextProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestContextProvider.java
new file mode 100644
index 0000000..49049f2
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestContextProvider.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal.spi;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * Provide access to the actual servlet request/response.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @see {@link RequestScopedInitializerProvider}
+ */
+public interface RequestContextProvider {
+
+ /**
+ * Get me the actual HTTP Servlet request.
+ *
+ * @return actual HTTP Servlet request.
+ */
+ public HttpServletRequest getHttpServletRequest();
+
+ /**
+ * Get me the actual HTTP Servlet response.
+ *
+ * @return actual HTTP Servlet response.
+ */
+ public HttpServletResponse getHttpServletResponse();
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestScopedInitializerProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestScopedInitializerProvider.java
new file mode 100644
index 0000000..ea18626
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/RequestScopedInitializerProvider.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal.spi;
+
+import org.glassfish.jersey.server.spi.RequestScopedInitializer;
+
+/**
+ * Produces {@link RequestScopedInitializer}
+ * based on provided {@link RequestContextProvider}.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public interface RequestScopedInitializerProvider {
+
+ /**
+ * Give me a request scope initializer that could be utilized
+ * to set the actual Servlet request data in injection manager.
+ *
+ * @param context of the actual request.
+ * @return initializer to be invoked at the start of request processing.
+ */
+ public RequestScopedInitializer get(RequestContextProvider context);
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ServletContainerProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ServletContainerProvider.java
new file mode 100644
index 0000000..2e9b697
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/ServletContainerProvider.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal.spi;
+
+import java.util.Set;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.RequestScopedInitializer;
+import org.glassfish.jersey.servlet.ServletContainer;
+
+/**
+ * This is internal Jersey SPI to hook to Jersey servlet initialization process driven by
+ * {@code org.glassfish.jersey.servlet.init.JerseyServletContainerInitializer}.
+ * The provider implementation class is registered via {@code META-INF/services}.
+ *
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @since 2.4.1
+ */
+public interface ServletContainerProvider {
+
+ /**
+ * Do your pre-initialization job before Jersey starts its servlet initialization.
+ *
+ * It is allowed to configure {@link ServletContext} or add/remove servlet registrations.
+ * Parameter {@code servletNames} contains list of names of currently registered Jersey servlets.
+ *
+ * @param servletContext the {@code ServletContext} of the JAX-RS/Jersey web application that is being started.
+ * @param classes the mutable Set of application classes that extend {@link javax.ws.rs.core.Application},
+ * implement, or have been annotated with the class types {@link javax.ws.rs.Path},
+ * {@link javax.ws.rs.ext.Provider} or {@link javax.ws.rs.ApplicationPath}.
+ * May be empty, never {@code null}.
+ * @throws ServletException if an error has occurred. {@code javax.servlet.ServletContainerInitializer.onStartup}
+ * is interrupted.
+ */
+ public void preInit(ServletContext servletContext, Set<Class<?>> classes) throws ServletException;
+
+ /**
+ * Do your post-initialization job after Jersey finished its servlet initialization.
+ *
+ * It is allowed to configure {@link ServletContext} or add/remove servlet registrations.
+ * Parameter {@code servletNames} contains list of names of currently registered Jersey servlets.
+ *
+ * @param servletContext the {@code ServletContext} of the JAX-RS/Jersey web application that is being started.
+ * @param classes the mutable Set of application classes that extend {@link javax.ws.rs.core.Application},
+ * implement, or have been annotated with the class types {@link javax.ws.rs.Path},
+ * {@link javax.ws.rs.ext.Provider} or {@link javax.ws.rs.ApplicationPath}.
+ * May be empty, never {@code null}.
+ * @param servletNames the Immutable set of Jersey's ServletContainer names. May be empty, never {@code null}.
+ * @throws ServletException if an error has occurred. {@code javax.servlet.ServletContainerInitializer.onStartup}
+ * is interrupted.
+ */
+ public void postInit(ServletContext servletContext, Set<Class<?>> classes, final Set<String> servletNames)
+ throws ServletException;
+
+ /**
+ * Notifies the provider about all registered Jersey servlets by its names.
+ *
+ * It is allowed to configure {@link ServletContext}. Do not add/remove any servlet registrations here.
+ *
+ * Parameter {@code servletNames} contains list of names of registered Jersey servlets.
+ * Currently it is {@link ServletContainer} or
+ * {@code org.glassfish.jersey.servlet.portability.PortableServletContainer} servlets.
+ *
+ * It does not matter servlet container is configured in {@code web.xml},
+ * by {@code org.glassfish.jersey.servlet.init.JerseyServletContainerInitializer}
+ * or by customer direct Servlet API calls.
+ *
+ * @param servletContext the {@code ServletContext} of the JAX-RS/Jersey web application that is being started.
+ * @param servletNames the Immutable set of Jersey's ServletContainer names. May be empty, never {@code null}.
+ * @throws ServletException if an error has occurred. {@code javax.servlet.ServletContainerInitializer.onStartup}
+ * is interrupted.
+ */
+ public void onRegister(ServletContext servletContext, final Set<String> servletNames) throws ServletException;
+
+ /**
+ * This method is called for each {@link ServletContainer} instance initialization,
+ * i.e. during {@link org.glassfish.jersey.servlet.WebComponent} initialization.
+ *
+ * The method is also called during {@link ServletContainer#reload()} or
+ * {@link ServletContainer#reload(ResourceConfig)} methods invocation.
+ *
+ * It does not matter servlet container is configured in {@code web.xml},
+ * by {@code org.glassfish.jersey.servlet.init.JerseyServletContainerInitializer}
+ * or by customer direct Servlet API calls.
+ *
+ * @param resourceConfig Jersey application configuration.
+ * @throws ServletException if an error has occurred. {@code org.glassfish.jersey.servlet.WebComponent} construction
+ * is interrupted.
+ */
+ public void configure(ResourceConfig resourceConfig) throws ServletException;
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/package-info.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/package-info.java
new file mode 100644
index 0000000..e0875ca
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/spi/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey internal Servlet SPI.
+ */
+package org.glassfish.jersey.servlet.internal.spi;
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/package-info.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/package-info.java
new file mode 100644
index 0000000..8e99e29
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey generic Servlet container integration classes.
+ */
+package org.glassfish.jersey.servlet;
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegate.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegate.java
new file mode 100644
index 0000000..99a02a8
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegate.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.spi;
+
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+/**
+ * Utilized by the Servlet container response writer to deal with the container async features.
+ * Individual instances are created by {@link AsyncContextDelegateProvider}.
+ *
+ * @see AsyncContextDelegateProvider
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public interface AsyncContextDelegate {
+
+ /**
+ * Invoked by the superior {@link ContainerResponseWriter} responsible for writing the response when processing is to be
+ * suspended. An implementation can throw an {@link UnsupportedOperationException} if suspend is not supported (the default
+ * behavior).
+ *
+ * @see ContainerResponseWriter#suspend(long, java.util.concurrent.TimeUnit, org.glassfish.jersey.server.spi.ContainerResponseWriter.TimeoutHandler)
+ * @throws IllegalStateException if underlying {@link javax.servlet.ServletRequest servlet request} throws an exception.
+ */
+ public void suspend() throws IllegalStateException;
+
+ /**
+ * Invoked upon a response writing completion when the response write is either committed or canceled.
+ */
+ public void complete();
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegateProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegateProvider.java
new file mode 100644
index 0000000..8503ff1
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegateProvider.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.spi;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * Factory to create {@link AsyncContextDelegate} to deal with asynchronous
+ * features added in Servlet version 3.0.
+ * If no such a factory is registered via the {@code META-INF/services} mechanism
+ * a default factory for Servlet versions prior to 3.0 will be utilized with no async support.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ */
+public interface AsyncContextDelegateProvider {
+
+ /**
+ * Factory method to create instances of Servlet container response writer extension,
+ * {@link AsyncContextDelegate}, for response processing.
+ *
+ * @param request original request.
+ * @param response original response.
+ * @return an instance to be used throughout a single response write processing.
+ */
+ public AsyncContextDelegate createDelegate(final HttpServletRequest request, final HttpServletResponse response);
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/FilterUrlMappingsProvider.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/FilterUrlMappingsProvider.java
new file mode 100644
index 0000000..a68b5ea
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/FilterUrlMappingsProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.spi;
+
+import javax.servlet.FilterConfig;
+import java.util.List;
+
+/**
+ * Provides an access to context path from the filter configuration.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ */
+public interface FilterUrlMappingsProvider {
+
+ /**
+ * Return configured context path from the filter configuration.
+ *
+ * @param filterConfig the {@link FilterConfig} object
+ * @returns the {@code List} of url-patterns
+ */
+ List<String> getFilterUrlMappings(final FilterConfig filterConfig);
+}
diff --git a/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/package-info.java b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/package-info.java
new file mode 100644
index 0000000..c8a1825
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * SPI for Jersey generic Servlet container support.
+ */
+package org.glassfish.jersey.servlet.spi;
diff --git a/containers/jersey-servlet-core/src/main/resources/org/glassfish/jersey/servlet/internal/localization.properties b/containers/jersey-servlet-core/src/main/resources/org/glassfish/jersey/servlet/internal/localization.properties
new file mode 100644
index 0000000..4250a68
--- /dev/null
+++ b/containers/jersey-servlet-core/src/main/resources/org/glassfish/jersey/servlet/internal/localization.properties
@@ -0,0 +1,34 @@
+#
+# Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+async.processing.not.supported=Asynchronous processing not supported on Servlet 2.x container.
+# {0} - status code; {1} - status reason message
+exception.sending.error.response=I/O exception occurred while sending "{0}/{1}" error response.
+form.param.consumed=A servlet request to the URI {0} contains form parameters in the request body but the request body has been consumed by the servlet or a servlet filter accessing the request parameters. Only resource methods using @FormParam will work as expected. Resource methods consuming the request body by other means will not work as expected.
+init.param.regex.syntax.invalid=The syntax is invalid for the regular expression "{0}" associated with the initialization parameter "{1}".
+# {0} - name (e.g. 'BookmarkPU')
+persistence.unit.not.configured=Persistence unit "{0}" is not configured as a servlet parameter in web.xml.
+# {0} - class name
+no.thread.local.value=No thread local value in scope for proxy of {0}.
+resource.config.parent.class.invalid=Resource configuration class {0} is not a subclass of {1}.
+resource.config.unable.to.load=Resource configuration class {0} could not be loaded.
+servlet.path.mismatch=The servlet path {0} does not start with the filter context path {1}.
+servlet.request.suspend.failed=Attempt to put servlet request into asynchronous mode has failed. Please check your servlet configuration \
+ - all Servlet instances and Servlet filters involved in the request processing must explicitly declare support for asynchronous request processing.
+header.value.read.failed=Attempt to read the header value failed.
+filter.context.path.missing=The root of the app was not properly defined. Either use a Servlet 3.x container or add \
+ an init-param 'jersey.config.servlet.filter.contextPath' to the filter configuration. Due to Servlet 2.x API, Jersey cannot \
+ determine the request base URI solely from the ServletContext. The application will most likely not work.
diff --git a/containers/jersey-servlet-core/src/test/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvokerTest.java b/containers/jersey-servlet-core/src/test/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvokerTest.java
new file mode 100644
index 0000000..b4476fc
--- /dev/null
+++ b/containers/jersey-servlet-core/src/test/java/org/glassfish/jersey/servlet/internal/ThreadLocalInvokerTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.internal;
+
+import java.lang.reflect.Proxy;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Michal Gajdos
+ */
+public class ThreadLocalInvokerTest {
+
+ public static class CheckedException extends Exception {
+
+ }
+
+ public static interface X {
+
+ public String checked() throws CheckedException;
+
+ public String runtime();
+ }
+
+ @Test
+ public void testIllegalState() {
+ final ThreadLocalInvoker<X> tli = new ThreadLocalInvoker<>();
+
+ final X x = (X) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{X.class}, tli);
+
+ boolean caught = false;
+ try {
+ x.checked();
+ } catch (final Exception ex) {
+ caught = true;
+ assertEquals(IllegalStateException.class, ex.getClass());
+ }
+ assertTrue(caught);
+
+ caught = false;
+ try {
+ x.runtime();
+ } catch (final Exception ex) {
+ caught = true;
+ assertEquals(IllegalStateException.class, ex.getClass());
+ }
+ assertTrue(caught);
+ }
+
+ @Test
+ public void testExceptions() {
+ final ThreadLocalInvoker<X> tli = new ThreadLocalInvoker<>();
+
+ final X x = (X) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{X.class}, tli);
+
+ tli.set(new X() {
+ public String checked() throws CheckedException {
+ throw new CheckedException();
+ }
+
+ public String runtime() {
+ throw new RuntimeException();
+ }
+ });
+
+ boolean caught = false;
+ try {
+ x.checked();
+ } catch (final Exception ex) {
+ caught = true;
+ assertEquals(CheckedException.class, ex.getClass());
+ }
+ assertTrue(caught);
+
+ caught = false;
+ try {
+ x.runtime();
+ } catch (final Exception ex) {
+ caught = true;
+ assertEquals(RuntimeException.class, ex.getClass());
+ }
+ assertTrue(caught);
+ }
+}
diff --git a/containers/jersey-servlet/pom.xml b/containers/jersey-servlet/pom.xml
new file mode 100644
index 0000000..a9a6634
--- /dev/null
+++ b/containers/jersey-servlet/pom.xml
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-servlet</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-servlet</name>
+
+ <description>Jersey core Servlet 3.x implementation</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>javax.servlet</groupId>
+ <artifactId>javax.servlet-api</artifactId>
+ <version>${servlet3.version}</version>
+ <scope>provided</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>jersey-container-servlet-core</artifactId>
+ <version>${project.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>javax.servlet</groupId>
+ <artifactId>servlet-api</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <!-- Note: When you're changing these properties change them also in bundles/jax-rs-ri/bundle/pom.xml. -->
+ <Import-Package>
+ javax.servlet.*;version="[3.0,5.0)",
+ javax.annotation.*;version=!,
+ *
+ </Import-Package>
+ </instructions>
+ <unpackBundle>true</unpackBundle>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/AsyncContextDelegateProviderImpl.java b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/AsyncContextDelegateProviderImpl.java
new file mode 100644
index 0000000..25ad283
--- /dev/null
+++ b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/AsyncContextDelegateProviderImpl.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.async;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.servlet.AsyncContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.servlet.init.internal.LocalizationMessages;
+import org.glassfish.jersey.servlet.spi.AsyncContextDelegate;
+import org.glassfish.jersey.servlet.spi.AsyncContextDelegateProvider;
+
+/**
+ * Servlet 3.x container response writer async extension and related extension factory implementation.
+ *
+ * @author Jakub Podlesak (jakub.podlesak at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class AsyncContextDelegateProviderImpl implements AsyncContextDelegateProvider {
+
+ private static final Logger LOGGER = Logger.getLogger(AsyncContextDelegateProviderImpl.class.getName());
+
+ @Override
+ public final AsyncContextDelegate createDelegate(final HttpServletRequest request, final HttpServletResponse response) {
+ return new ExtensionImpl(request, response);
+ }
+
+ private static final class ExtensionImpl implements AsyncContextDelegate {
+
+ private static final int NEVER_TIMEOUT_VALUE = -1;
+
+ private final HttpServletRequest request;
+ private final HttpServletResponse response;
+ private final AtomicReference<AsyncContext> asyncContextRef;
+ private final AtomicBoolean completed;
+
+ /**
+ * Create a Servlet 3.x {@link AsyncContextDelegate} with given {@code request} and {@code response}.
+ *
+ * @param request request to create {@link AsyncContext} for.
+ * @param response response to create {@link AsyncContext} for.
+ */
+ private ExtensionImpl(final HttpServletRequest request, final HttpServletResponse response) {
+ this.request = request;
+ this.response = response;
+ this.asyncContextRef = new AtomicReference<>();
+ this.completed = new AtomicBoolean(false);
+ }
+
+ @Override
+ public void suspend() throws IllegalStateException {
+ // Suspend only if not completed and not suspended before.
+ if (!completed.get() && asyncContextRef.get() == null) {
+ asyncContextRef.set(getAsyncContext());
+ }
+ }
+
+ private AsyncContext getAsyncContext() {
+ final AsyncContext asyncContext;
+ if (request.isAsyncStarted()) {
+ asyncContext = request.getAsyncContext();
+ try {
+ asyncContext.setTimeout(NEVER_TIMEOUT_VALUE);
+ } catch (IllegalStateException ex) {
+ // Let's hope the time out is set properly, otherwise JAX-RS AsyncResponse time-out support
+ // may not work as expected... At least we can log this at fine level...
+ LOGGER.log(Level.FINE, LocalizationMessages.SERVLET_ASYNC_CONTEXT_ALREADY_STARTED(), ex);
+ }
+ } else {
+ asyncContext = request.startAsync(request, response);
+ // Tell underlying asyncContext to never time out.
+ asyncContext.setTimeout(NEVER_TIMEOUT_VALUE);
+ }
+ return asyncContext;
+ }
+
+ @Override
+ public void complete() {
+ completed.set(true);
+
+ final AsyncContext asyncContext = asyncContextRef.getAndSet(null);
+ if (asyncContext != null) {
+ asyncContext.complete();
+ }
+ }
+ }
+}
diff --git a/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/package-info.java b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/package-info.java
new file mode 100644
index 0000000..0e02af9
--- /dev/null
+++ b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey servlet container asynchronous support classes.
+ */
+package org.glassfish.jersey.servlet.async;
diff --git a/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/FilterUrlMappingsProviderImpl.java b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/FilterUrlMappingsProviderImpl.java
new file mode 100644
index 0000000..e632f72
--- /dev/null
+++ b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/FilterUrlMappingsProviderImpl.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.init;
+
+import org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider;
+
+import javax.servlet.FilterConfig;
+import javax.servlet.FilterRegistration;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Provide all configured context paths (url mappings) of the application deployed using filter.
+ * <p>
+ * The url patterns are returned without the eventual trailing asterisk.
+ * <p>
+ * The functionality is available in Servlet 3.x environment only, so this
+ * implementation of {@link FilterUrlMappingsProvider} interface is Servlet 3 specific.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ */
+public class FilterUrlMappingsProviderImpl implements FilterUrlMappingsProvider {
+ @Override
+ public List<String> getFilterUrlMappings(FilterConfig filterConfig) {
+ FilterRegistration filterRegistration =
+ filterConfig.getServletContext().getFilterRegistration(filterConfig.getFilterName());
+
+ Collection<String> urlPatternMappings = filterRegistration.getUrlPatternMappings();
+ List<String> result = new ArrayList<>();
+
+ for (String pattern : urlPatternMappings) {
+ result.add(pattern.endsWith("*") ? pattern.substring(0, pattern.length() - 1) : pattern);
+ }
+
+ return result;
+ }
+}
diff --git a/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/JerseyServletContainerInitializer.java b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/JerseyServletContainerInitializer.java
new file mode 100644
index 0000000..5d58730
--- /dev/null
+++ b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/JerseyServletContainerInitializer.java
@@ -0,0 +1,378 @@
+/*
+ * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.init;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.ApplicationPath;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.ext.Provider;
+
+import javax.servlet.Registration;
+import javax.servlet.ServletContainerInitializer;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRegistration;
+import javax.servlet.annotation.HandlesTypes;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.servlet.ServletContainer;
+import org.glassfish.jersey.servlet.ServletProperties;
+import org.glassfish.jersey.servlet.init.internal.LocalizationMessages;
+import org.glassfish.jersey.servlet.internal.ServletContainerProviderFactory;
+import org.glassfish.jersey.servlet.internal.Utils;
+import org.glassfish.jersey.servlet.internal.spi.ServletContainerProvider;
+
+/*
+ It is RECOMMENDED that implementations support the Servlet 3 framework
+ pluggability mechanism to enable portability between containers and to avail
+ themselves of container-supplied class scanning facilities.
+ When using the pluggability mechanism the following conditions MUST be met:
+
+ - If no Application subclass is present the added servlet MUST be
+ named "javax.ws.rs.core.Application" and all root resource classes and
+ providers packaged in the web application MUST be included in the published
+ JAX-RS application. The application MUST be packaged with a web.xml that
+ specifies a servlet mapping for the added servlet.
+
+ - If an Application subclass is present and there is already a servlet defined
+ that has a servlet initialization parameter named "javax.ws.rs.Application"
+ whose value is the fully qualified name of the Application subclass then no
+ servlet should be added by the JAX-RS implementation's ContainerInitializer
+ since the application is already being handled by an existing servlet.
+
+ - If an application subclass is present that is not being handled by an
+ existing servlet then the servlet added by the ContainerInitializer MUST be
+ named with the fully qualified name of the Application subclass. If the
+ Application subclass is annotated with @PathPrefix and no servlet-mapping
+ exists for the added servlet then a new servlet mapping is added with the
+ value of the @PathPrefix annotation with "/*" appended otherwise the existing
+ mapping is used. If the Application subclass is not annotated with @PathPrefix
+ then the application MUST be packaged with a web.xml that specifies a servlet
+ mapping for the added servlet. It is an error for more than one Application
+ to be deployed at the same effective servlet mapping.
+
+ In either of the latter two cases, if both Application#getClasses and
+ Application#getSingletons return an empty list then all root resource classes
+ and providers packaged in the web application MUST be included in the
+ published JAX-RS application. If either getClasses or getSingletons return a
+ non-empty list then only those classes or singletons returned MUST be included
+ in the published JAX-RS application.
+
+ If not using the Servlet 3 framework pluggability mechanism
+ (e.g. in a pre-Servlet 3.0 container), the servlet-class or filter-class
+ element of the web.xml descriptor SHOULD name the JAX-RS
+ implementation-supplied Servlet or Filter class respectively. The
+ application-supplied subclass of Application SHOULD be identified using an
+ init-param with a param-name of javax.ws.rs.Application.
+ */
+
+/**
+ * {@link ServletContainerInitializer} implementation used for Servlet 3.x deployment.
+ *
+ * @author Paul Sandoz
+ * @author Martin Matula
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+@HandlesTypes({ Path.class, Provider.class, Application.class, ApplicationPath.class })
+public final class JerseyServletContainerInitializer implements ServletContainerInitializer {
+
+ private static final Logger LOGGER = Logger.getLogger(JerseyServletContainerInitializer.class.getName());
+
+ @Override
+ public void onStartup(Set<Class<?>> classes, final ServletContext servletContext) throws ServletException {
+ final ServletContainerProvider[] allServletContainerProviders =
+ ServletContainerProviderFactory.getAllServletContainerProviders();
+
+ if (classes == null) {
+ classes = Collections.emptySet();
+ }
+ // PRE INIT
+ for (final ServletContainerProvider servletContainerProvider : allServletContainerProviders) {
+ servletContainerProvider.preInit(servletContext, classes);
+ }
+ // INIT IMPL
+ onStartupImpl(classes, servletContext);
+ // POST INIT
+ for (final ServletContainerProvider servletContainerProvider : allServletContainerProviders) {
+ servletContainerProvider.postInit(servletContext, classes, findJerseyServletNames(servletContext));
+ }
+ // ON REGISTER
+ for (final ServletContainerProvider servletContainerProvider : allServletContainerProviders) {
+ servletContainerProvider.onRegister(servletContext, findJerseyServletNames(servletContext));
+ }
+ }
+
+ private void onStartupImpl(final Set<Class<?>> classes, final ServletContext servletContext) throws ServletException {
+ // first see if there are any application classes in the web app
+ for (final Class<? extends Application> applicationClass : getApplicationClasses(classes)) {
+ final ServletRegistration servletRegistration = servletContext.getServletRegistration(applicationClass.getName());
+
+ if (servletRegistration != null) {
+ addServletWithExistingRegistration(servletContext, servletRegistration, applicationClass, classes);
+ } else {
+ // Servlet is not registered with app name or the app name is used to register a different servlet
+ // check if some servlet defines the app in init params
+ final List<Registration> srs = getInitParamDeclaredRegistrations(servletContext, applicationClass);
+ if (!srs.isEmpty()) {
+ // app handled by at least one servlet or filter
+ // fix the registrations if needed (i.e. add servlet class)
+ for (final Registration sr : srs) {
+ if (sr instanceof ServletRegistration) {
+ addServletWithExistingRegistration(servletContext, (ServletRegistration) sr,
+ applicationClass, classes);
+ }
+ }
+ } else {
+ // app not handled by any servlet/filter -> add it
+ addServletWithApplication(servletContext, applicationClass, classes);
+ }
+ }
+ }
+
+ // check for javax.ws.rs.core.Application registration
+ addServletWithDefaultConfiguration(servletContext, classes);
+ }
+
+ /**
+ * Returns names of all registered Jersey servlets.
+ *
+ * Servlets are configured in {@code web.xml} or managed via Servlet API.
+ *
+ * @param servletContext the {@link ServletContext} of the web application that is being started
+ * @return list of Jersey servlet names or empty array, never returns {@code null}
+ */
+ private static Set<String> findJerseyServletNames(final ServletContext servletContext) {
+ final Set<String> jerseyServletNames = new HashSet<>();
+
+ for (final ServletRegistration servletRegistration : servletContext.getServletRegistrations().values()) {
+ if (isJerseyServlet(servletRegistration.getClassName())) {
+ jerseyServletNames.add(servletRegistration.getName());
+ }
+ }
+ return Collections.unmodifiableSet(jerseyServletNames);
+ }
+
+ /**
+ * Check if the {@code className} is an implementation of a Jersey Servlet container.
+ *
+ * @return {@code true} if the class is a Jersey servlet container class, {@code false} otherwise.
+ */
+ private static boolean isJerseyServlet(final String className) {
+ return ServletContainer.class.getName().equals(className)
+ || "org.glassfish.jersey.servlet.portability.PortableServletContainer".equals(className);
+ }
+
+ private static List<Registration> getInitParamDeclaredRegistrations(final ServletContext context,
+ final Class<? extends Application> clazz) {
+ final List<Registration> registrations = new ArrayList<>();
+ collectJaxRsRegistrations(context.getServletRegistrations(), registrations, clazz);
+ collectJaxRsRegistrations(context.getFilterRegistrations(), registrations, clazz);
+ return registrations;
+ }
+
+ private static void collectJaxRsRegistrations(final Map<String, ? extends Registration> registrations,
+ final List<Registration> collected, final Class<? extends Application> a) {
+ for (final Registration sr : registrations.values()) {
+ final Map<String, String> ips = sr.getInitParameters();
+ if (ips.containsKey(ServletProperties.JAXRS_APPLICATION_CLASS)) {
+ if (ips.get(ServletProperties.JAXRS_APPLICATION_CLASS).equals(a.getName())) {
+ collected.add(sr);
+ }
+ }
+ }
+ }
+
+ /**
+ * Enhance default servlet (named {@link Application}) configuration.
+ */
+ private static void addServletWithDefaultConfiguration(final ServletContext context,
+ final Set<Class<?>> classes) throws ServletException {
+
+ ServletRegistration registration = context.getServletRegistration(Application.class.getName());
+
+ if (registration != null) {
+ final Set<Class<?>> appClasses = getRootResourceAndProviderClasses(classes);
+ final ResourceConfig resourceConfig = ResourceConfig.forApplicationClass(ResourceConfig.class, appClasses)
+ .addProperties(getInitParams(registration))
+ .addProperties(Utils.getContextParams(context));
+
+ if (registration.getClassName() != null) {
+ // class name present - complete servlet registration from container point of view
+ Utils.store(resourceConfig, context, registration.getName());
+ } else {
+ // no class name - no complete servlet registration from container point of view
+ final ServletContainer servlet = new ServletContainer(resourceConfig);
+ registration = context.addServlet(registration.getName(), servlet);
+ ((ServletRegistration.Dynamic) registration).setLoadOnStartup(1);
+
+ if (registration.getMappings().isEmpty()) {
+ // Error
+ LOGGER.log(Level.WARNING, LocalizationMessages.JERSEY_APP_NO_MAPPING(registration.getName()));
+ } else {
+ LOGGER.log(Level.CONFIG,
+ LocalizationMessages.JERSEY_APP_REGISTERED_CLASSES(registration.getName(), appClasses));
+ }
+ }
+ }
+ }
+
+ /**
+ * Add new servlet according to {@link Application} subclass with {@link ApplicationPath} annotation or existing
+ * {@code servlet-mapping}.
+ */
+ private static void addServletWithApplication(final ServletContext context,
+ final Class<? extends Application> clazz,
+ final Set<Class<?>> defaultClasses) throws ServletException {
+ final ApplicationPath ap = clazz.getAnnotation(ApplicationPath.class);
+ if (ap != null) {
+ // App is annotated with ApplicationPath
+ final ResourceConfig resourceConfig = ResourceConfig.forApplicationClass(clazz, defaultClasses)
+ .addProperties(Utils.getContextParams(context));
+ final ServletContainer s = new ServletContainer(resourceConfig);
+ final ServletRegistration.Dynamic dsr = context.addServlet(clazz.getName(), s);
+ dsr.setAsyncSupported(true);
+ dsr.setLoadOnStartup(1);
+
+ final String mapping = createMappingPath(ap);
+ if (!mappingExists(context, mapping)) {
+ dsr.addMapping(mapping);
+
+ LOGGER.log(Level.CONFIG, LocalizationMessages.JERSEY_APP_REGISTERED_MAPPING(clazz.getName(), mapping));
+ } else {
+ LOGGER.log(Level.WARNING, LocalizationMessages.JERSEY_APP_MAPPING_CONFLICT(clazz.getName(), mapping));
+ }
+ }
+ }
+
+ /**
+ * Enhance existing servlet configuration.
+ */
+ private static void addServletWithExistingRegistration(final ServletContext context,
+ ServletRegistration registration,
+ final Class<? extends Application> clazz,
+ final Set<Class<?>> classes) throws ServletException {
+ // create a new servlet container for a given app.
+ final ResourceConfig resourceConfig = ResourceConfig.forApplicationClass(clazz, classes)
+ .addProperties(getInitParams(registration))
+ .addProperties(Utils.getContextParams(context));
+
+ if (registration.getClassName() != null) {
+ // class name present - complete servlet registration from container point of view
+ Utils.store(resourceConfig, context, registration.getName());
+ } else {
+ // no class name - no complete servlet registration from container point of view
+ final ServletContainer servlet = new ServletContainer(resourceConfig);
+ final ServletRegistration.Dynamic dynamicRegistration = context.addServlet(clazz.getName(), servlet);
+ dynamicRegistration.setAsyncSupported(true);
+ dynamicRegistration.setLoadOnStartup(1);
+ registration = dynamicRegistration;
+ }
+ if (registration.getMappings().isEmpty()) {
+ final ApplicationPath ap = clazz.getAnnotation(ApplicationPath.class);
+ if (ap != null) {
+ final String mapping = createMappingPath(ap);
+ if (!mappingExists(context, mapping)) {
+ registration.addMapping(mapping);
+
+ LOGGER.log(Level.CONFIG, LocalizationMessages.JERSEY_APP_REGISTERED_MAPPING(clazz.getName(), mapping));
+ } else {
+ LOGGER.log(Level.WARNING, LocalizationMessages.JERSEY_APP_MAPPING_CONFLICT(clazz.getName(), mapping));
+ }
+ } else {
+ // Error
+ LOGGER.log(Level.WARNING, LocalizationMessages.JERSEY_APP_NO_MAPPING_OR_ANNOTATION(clazz.getName(),
+ ApplicationPath.class.getSimpleName()));
+ }
+ } else {
+ LOGGER.log(Level.CONFIG, LocalizationMessages.JERSEY_APP_REGISTERED_APPLICATION(clazz.getName()));
+ }
+ }
+
+ private static Map<String, Object> getInitParams(final ServletRegistration sr) {
+ final Map<String, Object> initParams = new HashMap<>();
+ for (final Map.Entry<String, String> entry : sr.getInitParameters().entrySet()) {
+ initParams.put(entry.getKey(), entry.getValue());
+ }
+ return initParams;
+ }
+
+ private static boolean mappingExists(final ServletContext sc, final String mapping) {
+ for (final ServletRegistration sr : sc.getServletRegistrations().values()) {
+ for (final String declaredMapping : sr.getMappings()) {
+ if (mapping.equals(declaredMapping)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+
+
+ private static String createMappingPath(final ApplicationPath ap) {
+ String path = ap.value();
+ if (!path.startsWith("/")) {
+ path = "/" + path;
+ }
+
+ if (!path.endsWith("/*")) {
+ if (path.endsWith("/")) {
+ path += "*";
+ } else {
+ path += "/*";
+ }
+ }
+
+ return path;
+ }
+
+ private static Set<Class<? extends Application>> getApplicationClasses(final Set<Class<?>> classes) {
+ final Set<Class<? extends Application>> s = new LinkedHashSet<>();
+ for (final Class<?> c : classes) {
+ if (Application.class != c && Application.class.isAssignableFrom(c)) {
+ s.add(c.asSubclass(Application.class));
+ }
+ }
+
+ return s;
+ }
+
+ private static Set<Class<?>> getRootResourceAndProviderClasses(final Set<Class<?>> classes) {
+ // TODO filter out any classes from the Jersey jars
+ final Set<Class<?>> s = new LinkedHashSet<>();
+ for (final Class<?> c : classes) {
+ if (c.isAnnotationPresent(Path.class) || c.isAnnotationPresent(Provider.class)) {
+ s.add(c);
+ }
+ }
+
+ return s;
+ }
+
+}
diff --git a/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/package-info.java b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/package-info.java
new file mode 100644
index 0000000..c19811d
--- /dev/null
+++ b/containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/init/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey servlet container initialization classes.
+ */
+package org.glassfish.jersey.servlet.init;
diff --git a/containers/jersey-servlet/src/main/resources/META-INF/services/javax.servlet.ServletContainerInitializer b/containers/jersey-servlet/src/main/resources/META-INF/services/javax.servlet.ServletContainerInitializer
new file mode 100644
index 0000000..4052e74
--- /dev/null
+++ b/containers/jersey-servlet/src/main/resources/META-INF/services/javax.servlet.ServletContainerInitializer
@@ -0,0 +1 @@
+org.glassfish.jersey.servlet.init.JerseyServletContainerInitializer
\ No newline at end of file
diff --git a/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.AsyncContextDelegateProvider b/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.AsyncContextDelegateProvider
new file mode 100644
index 0000000..959ec7c
--- /dev/null
+++ b/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.AsyncContextDelegateProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.servlet.async.AsyncContextDelegateProviderImpl
\ No newline at end of file
diff --git a/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider b/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider
new file mode 100644
index 0000000..6f15689
--- /dev/null
+++ b/containers/jersey-servlet/src/main/resources/META-INF/services/org.glassfish.jersey.servlet.spi.FilterUrlMappingsProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.servlet.init.FilterUrlMappingsProviderImpl
\ No newline at end of file
diff --git a/containers/jersey-servlet/src/main/resources/org/glassfish/jersey/servlet/init/internal/localization.properties b/containers/jersey-servlet/src/main/resources/org/glassfish/jersey/servlet/init/internal/localization.properties
new file mode 100644
index 0000000..6f1b074
--- /dev/null
+++ b/containers/jersey-servlet/src/main/resources/org/glassfish/jersey/servlet/init/internal/localization.properties
@@ -0,0 +1,24 @@
+#
+# Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+jersey.app.mapping.conflict=Mapping conflict. A Servlet registration exists with same mapping as the Jersey servlet application, named {0}, at the servlet mapping, {1}.
+jersey.app.no.mapping=The Jersey servlet application, named {0}, has no servlet mapping.
+jersey.app.no.mapping.or.annotation=The Jersey servlet application, named {0}, is not annotated with {1} and has no servlet mapping.
+jersey.app.registered.classes=Registering the Jersey servlet application, named {0}, with the following root resource and provider classes: {1}
+jersey.app.registered.mapping=Registering the Jersey servlet application, named {0}, at the servlet mapping {1}, with the Application class of the same name.
+jersey.app.registered.application=Registering the Jersey servlet application, named {0}, with the Application class of the same name.
+servlet.async.context.already.started=Servlet request has been put into asynchronous mode by an external force. \
+ Proceeding with the existing AsyncContext instance, but cannot guarantee the correct behavior of JAX-RS AsyncResponse time-out support.
diff --git a/containers/jetty-http/pom.xml b/containers/jetty-http/pom.xml
new file mode 100644
index 0000000..eb3d0b8
--- /dev/null
+++ b/containers/jetty-http/pom.xml
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <artifactId>project</artifactId>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-jetty-http</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-jetty-http</name>
+
+ <description>Jetty Http Container</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-server</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-continuation</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+
+ </plugins>
+
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ </build>
+
+ <profiles>
+ <profile>
+ <id>testsSkipJdk6</id>
+ <activation>
+ <jdk>1.6</jdk>
+ </activation>
+ <properties>
+ <skip.tests>true</skip.tests>
+ </properties>
+ </profile>
+ </profiles>
+
+</project>
diff --git a/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainer.java b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainer.java
new file mode 100644
index 0000000..fa93775
--- /dev/null
+++ b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainer.java
@@ -0,0 +1,459 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.Principal;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.SecurityContext;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.glassfish.jersey.internal.MapPropertiesDelegate;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.ReferencingFactory;
+import org.glassfish.jersey.internal.util.ExtendedLogger;
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.jetty.internal.LocalizationMessages;
+import org.glassfish.jersey.process.internal.RequestScoped;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.ServerProperties;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+import org.eclipse.jetty.continuation.Continuation;
+import org.eclipse.jetty.continuation.ContinuationListener;
+import org.eclipse.jetty.continuation.ContinuationSupport;
+import org.eclipse.jetty.http.HttpStatus;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Response;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+
+/**
+ * Jersey {@code Container} implementation based on Jetty {@link org.eclipse.jetty.server.Handler}.
+ *
+ * @author Arul Dhesiaseelan (aruld@acm.org)
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class JettyHttpContainer extends AbstractHandler implements Container {
+
+ private static final ExtendedLogger LOGGER =
+ new ExtendedLogger(Logger.getLogger(JettyHttpContainer.class.getName()), Level.FINEST);
+
+ private static final Type REQUEST_TYPE = (new GenericType<Ref<Request>>() {}).getType();
+ private static final Type RESPONSE_TYPE = (new GenericType<Ref<Response>>() {}).getType();
+
+ private static final int INTERNAL_SERVER_ERROR = javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR.getStatusCode();
+
+ /**
+ * Cached value of configuration property
+ * {@link org.glassfish.jersey.server.ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR}.
+ * If {@code true} method {@link HttpServletResponse#setStatus} is used over {@link HttpServletResponse#sendError}.
+ */
+ private boolean configSetStatusOverSendError;
+
+ /**
+ * Referencing factory for Jetty request.
+ */
+ private static class JettyRequestReferencingFactory extends ReferencingFactory<Request> {
+ @Inject
+ public JettyRequestReferencingFactory(final Provider<Ref<Request>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * Referencing factory for Jetty response.
+ */
+ private static class JettyResponseReferencingFactory extends ReferencingFactory<Response> {
+ @Inject
+ public JettyResponseReferencingFactory(final Provider<Ref<Response>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * An internal binder to enable Jetty HTTP container specific types injection.
+ * This binder allows to inject underlying Jetty HTTP request and response instances.
+ * Note that since Jetty {@code Request} class is not proxiable as it does not expose an empty constructor,
+ * the injection of Jetty request instance into singleton JAX-RS and Jersey providers is only supported via
+ * {@link javax.inject.Provider injection provider}.
+ */
+ private static class JettyBinder extends AbstractBinder {
+
+ @Override
+ protected void configure() {
+ bindFactory(JettyRequestReferencingFactory.class).to(Request.class)
+ .proxy(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Request>referenceFactory()).to(new GenericType<Ref<Request>>() {})
+ .in(RequestScoped.class);
+
+ bindFactory(JettyResponseReferencingFactory.class).to(Response.class)
+ .proxy(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Response>referenceFactory()).to(new GenericType<Ref<Response>>() {})
+ .in(RequestScoped.class);
+ }
+ }
+
+ private volatile ApplicationHandler appHandler;
+
+ @Override
+ public void handle(final String target, final Request request, final HttpServletRequest httpServletRequest,
+ final HttpServletResponse httpServletResponse) throws IOException, ServletException {
+
+ final Response response = request.getResponse();
+ final ResponseWriter responseWriter = new ResponseWriter(request, response, configSetStatusOverSendError);
+ final URI baseUri = getBaseUri(request);
+ final URI requestUri = getRequestUri(request, baseUri);
+ try {
+ final ContainerRequest requestContext = new ContainerRequest(
+ baseUri,
+ requestUri,
+ request.getMethod(),
+ getSecurityContext(request),
+ new MapPropertiesDelegate());
+ requestContext.setEntityStream(request.getInputStream());
+ final Enumeration<String> headerNames = request.getHeaderNames();
+ while (headerNames.hasMoreElements()) {
+ final String headerName = headerNames.nextElement();
+ String headerValue = request.getHeader(headerName);
+ requestContext.headers(headerName, headerValue == null ? "" : headerValue);
+ }
+ requestContext.setWriter(responseWriter);
+ requestContext.setRequestScopedInitializer(injectionManager -> {
+ injectionManager.<Ref<Request>>getInstance(REQUEST_TYPE).set(request);
+ injectionManager.<Ref<Response>>getInstance(RESPONSE_TYPE).set(response);
+ });
+
+ // Mark the request as handled before generating the body of the response
+ request.setHandled(true);
+ appHandler.handle(requestContext);
+ } catch (final Exception ex) {
+ throw new RuntimeException(ex);
+ }
+
+ }
+
+ private URI getRequestUri(final Request request, final URI baseUri) {
+ try {
+ final String serverAddress = getServerAddress(baseUri);
+ String uri = request.getRequestURI();
+
+ final String queryString = request.getQueryString();
+ if (queryString != null) {
+ uri = uri + "?" + ContainerUtils.encodeUnsafeCharacters(queryString);
+ }
+
+ return new URI(serverAddress + uri);
+ } catch (URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getServerAddress(URI baseUri) {
+ String serverAddress = baseUri.toString();
+ if (serverAddress.charAt(serverAddress.length() - 1) == '/') {
+ return serverAddress.substring(0, serverAddress.length() - 1);
+ }
+ return serverAddress;
+ }
+
+ private SecurityContext getSecurityContext(final Request request) {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return request.isUserInRole(role);
+ }
+
+ @Override
+ public boolean isSecure() {
+ return request.isSecure();
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return request.getUserPrincipal();
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return request.getAuthType();
+ }
+ };
+ }
+
+
+ private URI getBaseUri(final Request request) {
+ try {
+ return new URI(request.getScheme(), null, request.getServerName(),
+ request.getServerPort(), getBasePath(request), null, null);
+ } catch (final URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getBasePath(final Request request) {
+ final String contextPath = request.getContextPath();
+
+ if (contextPath == null || contextPath.isEmpty()) {
+ return "/";
+ } else if (contextPath.charAt(contextPath.length() - 1) != '/') {
+ return contextPath + "/";
+ } else {
+ return contextPath;
+ }
+ }
+
+ private static final class ResponseWriter implements ContainerResponseWriter {
+
+ private final Response response;
+ private final Continuation continuation;
+ private final boolean configSetStatusOverSendError;
+
+ ResponseWriter(final Request request, final Response response, final boolean configSetStatusOverSendError) {
+ this.response = response;
+ this.continuation = ContinuationSupport.getContinuation(request);
+ this.configSetStatusOverSendError = configSetStatusOverSendError;
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(final long contentLength, final ContainerResponse context)
+ throws ContainerException {
+
+ final javax.ws.rs.core.Response.StatusType statusInfo = context.getStatusInfo();
+
+ final int code = statusInfo.getStatusCode();
+ final String reason = statusInfo.getReasonPhrase() == null
+ ? HttpStatus.getMessage(code) : statusInfo.getReasonPhrase();
+
+ response.setStatusWithReason(code, reason);
+
+ if (contentLength != -1 && contentLength < Integer.MAX_VALUE) {
+ response.setContentLength((int) contentLength);
+ }
+ for (final Map.Entry<String, List<String>> e : context.getStringHeaders().entrySet()) {
+ for (final String value : e.getValue()) {
+ response.addHeader(e.getKey(), value);
+ }
+ }
+
+ try {
+ return response.getOutputStream();
+ } catch (final IOException ioe) {
+ throw new ContainerException("Error during writing out the response headers.", ioe);
+ }
+ }
+
+ @Override
+ public boolean suspend(final long timeOut, final TimeUnit timeUnit, final TimeoutHandler timeoutHandler) {
+ try {
+ if (timeOut > 0) {
+ final long timeoutMillis = TimeUnit.MILLISECONDS.convert(timeOut, timeUnit);
+ continuation.setTimeout(timeoutMillis);
+ }
+ continuation.addContinuationListener(new ContinuationListener() {
+ @Override
+ public void onComplete(final Continuation continuation) {
+ }
+
+ @Override
+ public void onTimeout(final Continuation continuation) {
+ if (timeoutHandler != null) {
+ timeoutHandler.onTimeout(ResponseWriter.this);
+ }
+ }
+ });
+ continuation.suspend(response);
+ return true;
+ } catch (final Exception ex) {
+ return false;
+ }
+ }
+
+ @Override
+ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit) throws IllegalStateException {
+ if (timeOut > 0) {
+ final long timeoutMillis = TimeUnit.MILLISECONDS.convert(timeOut, timeUnit);
+ continuation.setTimeout(timeoutMillis);
+ }
+ }
+
+ @Override
+ public void commit() {
+ try {
+ response.closeOutput();
+ } catch (final IOException e) {
+ LOGGER.log(Level.WARNING, LocalizationMessages.UNABLE_TO_CLOSE_RESPONSE(), e);
+ } finally {
+ if (continuation.isSuspended()) {
+ continuation.complete();
+ }
+ LOGGER.log(Level.FINEST, "commit() called");
+ }
+ }
+
+ @Override
+ public void failure(final Throwable error) {
+ try {
+ if (!response.isCommitted()) {
+ try {
+ if (configSetStatusOverSendError) {
+ response.reset();
+ //noinspection deprecation
+ response.setStatus(INTERNAL_SERVER_ERROR, "Request failed.");
+ } else {
+ response.sendError(INTERNAL_SERVER_ERROR, "Request failed.");
+ }
+ } catch (final IllegalStateException ex) {
+ // a race condition externally committing the response can still occur...
+ LOGGER.log(Level.FINER, "Unable to reset failed response.", ex);
+ } catch (final IOException ex) {
+ throw new ContainerException(LocalizationMessages.EXCEPTION_SENDING_ERROR_RESPONSE(INTERNAL_SERVER_ERROR,
+ "Request failed."), ex);
+ }
+ }
+ } finally {
+ LOGGER.log(Level.FINEST, "failure(...) called");
+ commit();
+ rethrow(error);
+ }
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return false;
+ }
+
+ /**
+ * Rethrow the original exception as required by JAX-RS, 3.3.4.
+ *
+ * @param error throwable to be re-thrown
+ */
+ private void rethrow(final Throwable error) {
+ if (error instanceof RuntimeException) {
+ throw (RuntimeException) error;
+ } else {
+ throw new ContainerException(error);
+ }
+ }
+
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return appHandler.getConfiguration();
+ }
+
+ @Override
+ public void reload() {
+ reload(getConfiguration());
+ }
+
+ @Override
+ public void reload(final ResourceConfig configuration) {
+ appHandler.onShutdown(this);
+
+ appHandler = new ApplicationHandler(configuration.register(new JettyBinder()));
+ appHandler.onReload(this);
+ appHandler.onStartup(this);
+ cacheConfigSetStatusOverSendError();
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return appHandler;
+ }
+
+ /**
+ * Inform this container that the server has been started.
+ * This method must be implicitly called after the server containing this container is started.
+ *
+ * @throws java.lang.Exception if a problem occurred during server startup.
+ */
+ @Override
+ protected void doStart() throws Exception {
+ super.doStart();
+ appHandler.onStartup(this);
+ }
+
+ /**
+ * Inform this container that the server is being stopped.
+ * This method must be implicitly called before the server containing this container is stopped.
+ *
+ * @throws java.lang.Exception if a problem occurred during server shutdown.
+ */
+ @Override
+ public void doStop() throws Exception {
+ super.doStop();
+ appHandler.onShutdown(this);
+ appHandler = null;
+ }
+
+ /**
+ * Create a new Jetty HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Jetty HTTP container.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ */
+ JettyHttpContainer(final Application application, final Object parentContext) {
+ this.appHandler = new ApplicationHandler(application, new JettyBinder(), parentContext);
+ }
+
+ /**
+ * Create a new Jetty HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Jetty HTTP container.
+ */
+ JettyHttpContainer(final Application application) {
+ this.appHandler = new ApplicationHandler(application, new JettyBinder());
+
+ cacheConfigSetStatusOverSendError();
+ }
+
+ /**
+ * The method reads and caches value of configuration property
+ * {@link ServerProperties#RESPONSE_SET_STATUS_OVER_SEND_ERROR} for future purposes.
+ */
+ private void cacheConfigSetStatusOverSendError() {
+ this.configSetStatusOverSendError = ServerProperties.getValue(getConfiguration().getProperties(),
+ ServerProperties.RESPONSE_SET_STATUS_OVER_SEND_ERROR, false, Boolean.class);
+ }
+
+}
diff --git a/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerFactory.java b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerFactory.java
new file mode 100644
index 0000000..8155ea7
--- /dev/null
+++ b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerFactory.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import java.net.URI;
+import java.util.concurrent.ThreadFactory;
+
+import javax.ws.rs.ProcessingException;
+
+import org.glassfish.jersey.internal.guava.ThreadFactoryBuilder;
+import org.glassfish.jersey.jetty.internal.LocalizationMessages;
+import org.glassfish.jersey.process.JerseyProcessingUncaughtExceptionHandler;
+import org.glassfish.jersey.server.ContainerFactory;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.Container;
+
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.HttpConfiguration;
+import org.eclipse.jetty.server.HttpConnectionFactory;
+import org.eclipse.jetty.server.SecureRequestCustomizer;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.SslConnectionFactory;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+
+/**
+ * Factory for creating and starting Jetty server handlers. This returns
+ * a handle to the started server as {@link Server} instances, which allows
+ * the server to be stopped by invoking the {@link org.eclipse.jetty.server.Server#stop()} method.
+ * <p/>
+ * To start the server in HTTPS mode an {@link SslContextFactory} can be provided.
+ * This will be used to decrypt and encrypt information sent over the
+ * connected TCP socket channel.
+ *
+ * @author Arul Dhesiaseelan (aruld@acm.org)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class JettyHttpContainerFactory {
+
+ private JettyHttpContainerFactory() {
+ }
+
+ /**
+ * Creates a {@link Server} instance that registers an {@link org.eclipse.jetty.server.Handler}.
+ *
+ * @param uri uri on which the {@link org.glassfish.jersey.server.ApplicationHandler} will be deployed. Only first path
+ * segment will be used as context path, the rest will be ignored.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ */
+ public static Server createServer(final URI uri) throws ProcessingException {
+ return createServer(uri, null, null, true);
+ }
+
+ /**
+ * Creates a {@link Server} instance that registers an {@link org.eclipse.jetty.server.Handler}.
+ *
+ * @param uri uri on which the {@link org.glassfish.jersey.server.ApplicationHandler} will be deployed. Only first path
+ * segment will be used as context path, the rest will be ignored.
+ * @param start if set to false, server will not get started, which allows to configure the underlying transport
+ * layer, see above for details.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ */
+ public static Server createServer(final URI uri, final boolean start) throws ProcessingException {
+ return createServer(uri, null, null, start);
+ }
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes declared by the
+ * resource configuration.
+ * <p/>
+ * This implementation defers to the
+ * {@link org.glassfish.jersey.server.ContainerFactory#createContainer(Class, javax.ws.rs.core.Application)} method
+ * for creating an Container that manages the root resources.
+ *
+ * @param uri the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI path, query and fragment components are ignored.
+ * @param config the resource configuration.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ */
+ public static Server createServer(final URI uri, final ResourceConfig config)
+ throws ProcessingException {
+
+ final JettyHttpContainer container = ContainerFactory.createContainer(JettyHttpContainer.class, config);
+ return createServer(uri, null, container, true);
+ }
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes declared by the
+ * resource configuration.
+ * <p/>
+ * This implementation defers to the
+ * {@link org.glassfish.jersey.server.ContainerFactory#createContainer(Class, javax.ws.rs.core.Application)} method
+ * for creating an Container that manages the root resources.
+ *
+ * @param uri URI on which the Jersey web application will be deployed. Only first path segment will be
+ * used as context path, the rest will be ignored.
+ * @param configuration web application configuration.
+ * @param start if set to false, server will not get started, which allows to configure the underlying
+ * transport layer, see above for details.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ */
+ public static Server createServer(final URI uri, final ResourceConfig configuration, final boolean start)
+ throws ProcessingException {
+ return createServer(uri, null, ContainerFactory.createContainer(JettyHttpContainer.class, configuration), start);
+ }
+
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes declared by the
+ * resource configuration.
+ *
+ * @param uri the URI to create the http server. The URI scheme must be
+ * equal to "https". The URI user information and host
+ * are ignored If the URI port is not present then port 143 will be
+ * used. The URI path, query and fragment components are ignored.
+ * @param config the resource configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @param start if set to false, server will not get started, this allows end users to set
+ * additional properties on the underlying listener.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ * @see JettyHttpContainer
+ * @since 2.12
+ */
+ public static Server createServer(final URI uri, final ResourceConfig config, final boolean start,
+ final Object parentContext) {
+ return createServer(uri, null, new JettyHttpContainer(config, parentContext), start);
+ }
+
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes declared by the
+ * resource configuration.
+ *
+ * @param uri the URI to create the http server. The URI scheme must be
+ * equal to "https". The URI user information and host
+ * are ignored If the URI port is not present then port 143 will be
+ * used. The URI path, query and fragment components are ignored.
+ * @param config the resource configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ * @see JettyHttpContainer
+ * @since 2.12
+ */
+ public static Server createServer(final URI uri, final ResourceConfig config, final Object parentContext) {
+ return createServer(uri, null, new JettyHttpContainer(config, parentContext), true);
+ }
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes declared by the
+ * resource configuration.
+ * <p/>
+ * This implementation defers to the
+ * {@link ContainerFactory#createContainer(Class, javax.ws.rs.core.Application)} method
+ * for creating an Container that manages the root resources.
+ *
+ * @param uri the URI to create the http server. The URI scheme must be
+ * equal to {@code https}. The URI user information and host
+ * are ignored. If the URI port is not present then port
+ * {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be
+ * used. The URI path, query and fragment components are ignored.
+ * @param sslContextFactory this is the SSL context factory used to configure SSL connector
+ * @param config the resource configuration.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ */
+ public static Server createServer(final URI uri, final SslContextFactory sslContextFactory, final ResourceConfig config)
+ throws ProcessingException {
+ final JettyHttpContainer container = ContainerFactory.createContainer(JettyHttpContainer.class, config);
+ return createServer(uri, sslContextFactory, container, true);
+ }
+
+ /**
+ * Create a {@link Server} that registers an {@link org.eclipse.jetty.server.Handler} that
+ * in turn manages all root resource and provider classes found by searching the
+ * classes referenced in the java classpath.
+ *
+ * @param uri the URI to create the http server. The URI scheme must be
+ * equal to {@code https}. The URI user information and host
+ * are ignored. If the URI port is not present then port
+ * {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be
+ * used. The URI path, query and fragment components are ignored.
+ * @param sslContextFactory this is the SSL context factory used to configure SSL connector
+ * @param handler the container that handles all HTTP requests
+ * @param start if set to false, server will not get started, this allows end users to set
+ * additional properties on the underlying listener.
+ * @return newly created {@link Server}.
+ *
+ * @throws ProcessingException in case of any failure when creating a new Jetty {@code Server} instance.
+ * @throws IllegalArgumentException if {@code uri} is {@code null}.
+ * @see JettyHttpContainer
+ */
+ public static Server createServer(final URI uri,
+ final SslContextFactory sslContextFactory,
+ final JettyHttpContainer handler,
+ final boolean start) {
+ if (uri == null) {
+ throw new IllegalArgumentException(LocalizationMessages.URI_CANNOT_BE_NULL());
+ }
+ final String scheme = uri.getScheme();
+ int defaultPort = Container.DEFAULT_HTTP_PORT;
+
+ if (sslContextFactory == null) {
+ if (!"http".equalsIgnoreCase(scheme)) {
+ throw new IllegalArgumentException(LocalizationMessages.WRONG_SCHEME_WHEN_USING_HTTP());
+ }
+ } else {
+ if (!"https".equalsIgnoreCase(scheme)) {
+ throw new IllegalArgumentException(LocalizationMessages.WRONG_SCHEME_WHEN_USING_HTTPS());
+ }
+ defaultPort = Container.DEFAULT_HTTPS_PORT;
+ }
+ final int port = (uri.getPort() == -1) ? defaultPort : uri.getPort();
+
+ final Server server = new Server(new JettyConnectorThreadPool());
+ final HttpConfiguration config = new HttpConfiguration();
+ if (sslContextFactory != null) {
+ config.setSecureScheme("https");
+ config.setSecurePort(port);
+ config.addCustomizer(new SecureRequestCustomizer());
+
+ final ServerConnector https = new ServerConnector(server,
+ new SslConnectionFactory(sslContextFactory, "http/1.1"),
+ new HttpConnectionFactory(config));
+ https.setPort(port);
+ server.setConnectors(new Connector[]{https});
+
+ } else {
+ final ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(config));
+ http.setPort(port);
+ server.setConnectors(new Connector[]{http});
+ }
+ if (handler != null) {
+ server.setHandler(handler);
+ }
+
+ if (start) {
+ try {
+ // Start the server.
+ server.start();
+ } catch (final Exception e) {
+ throw new ProcessingException(LocalizationMessages.ERROR_WHEN_CREATING_SERVER(), e);
+ }
+ }
+ return server;
+ }
+
+ private static final class JettyConnectorThreadPool extends QueuedThreadPool {
+ private final ThreadFactory threadFactory = new ThreadFactoryBuilder()
+ .setNameFormat("jetty-http-server-%d")
+ .setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler())
+ .build();
+
+ @Override
+ protected Thread newThread(Runnable runnable) {
+ return threadFactory.newThread(runnable);
+ }
+ }
+}
diff --git a/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerProvider.java b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerProvider.java
new file mode 100644
index 0000000..15afcbf
--- /dev/null
+++ b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/JettyHttpContainerProvider.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Application;
+
+import org.glassfish.jersey.server.spi.ContainerProvider;
+
+import org.eclipse.jetty.server.Handler;
+
+/**
+ * Container provider for containers based on Jetty Server {@link org.eclipse.jetty.server.Handler}.
+ *
+ * @author Arul Dhesiaseelan (aruld@acm.org)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class JettyHttpContainerProvider implements ContainerProvider {
+
+ @Override
+ public <T> T createContainer(final Class<T> type, final Application application) throws ProcessingException {
+ if (Handler.class == type || JettyHttpContainer.class == type) {
+ return type.cast(new JettyHttpContainer(application));
+ }
+ return null;
+ }
+
+}
diff --git a/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/package-info.java b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/package-info.java
new file mode 100644
index 0000000..4ea14bf
--- /dev/null
+++ b/containers/jetty-http/src/main/java/org/glassfish/jersey/jetty/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey Jetty container classes.
+ */
+package org.glassfish.jersey.jetty;
diff --git a/containers/jetty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider b/containers/jetty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
new file mode 100644
index 0000000..1496edb
--- /dev/null
+++ b/containers/jetty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.jetty.JettyHttpContainerProvider
\ No newline at end of file
diff --git a/containers/jetty-http/src/main/resources/org/glassfish/jersey/jetty/internal/localization.properties b/containers/jetty-http/src/main/resources/org/glassfish/jersey/jetty/internal/localization.properties
new file mode 100644
index 0000000..b1528f8
--- /dev/null
+++ b/containers/jetty-http/src/main/resources/org/glassfish/jersey/jetty/internal/localization.properties
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+# {0} - status code; {1} - status reason message
+exception.sending.error.response=I/O exception occurred while sending "{0}/{1}" error response.
+error.when.creating.server=Exception thrown when trying to create jetty server.
+unable.to.close.response=Unable to close response output.
+uri.cannot.be.null=The URI must not be null.
+wrong.scheme.when.using.http=The URI scheme should be 'http' when not using SSL.
+wrong.scheme.when.using.https=The URI scheme should be 'https' when using SSL.
diff --git a/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AbstractJettyServerTester.java b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AbstractJettyServerTester.java
new file mode 100644
index 0000000..dcfe4b7
--- /dev/null
+++ b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AbstractJettyServerTester.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import java.net.URI;
+import java.security.AccessController;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.logging.LoggingFeature;
+import org.glassfish.jersey.internal.util.PropertiesHelper;
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.eclipse.jetty.server.Server;
+import org.junit.After;
+
+/**
+ * Abstract Jetty Server unit tester.
+ *
+ * @author Paul Sandoz
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ * @author Miroslav Fuksa
+ */
+public abstract class AbstractJettyServerTester {
+
+ private static final Logger LOGGER = Logger.getLogger(AbstractJettyServerTester.class.getName());
+
+ public static final String CONTEXT = "";
+ private static final int DEFAULT_PORT = 9998;
+
+ /**
+ * Get the port to be used for test application deployments.
+ *
+ * @return The HTTP port of the URI
+ */
+ protected final int getPort() {
+ final String value = AccessController
+ .doPrivileged(PropertiesHelper.getSystemProperty("jersey.config.test.container.port"));
+ if (value != null) {
+
+ try {
+ final int i = Integer.parseInt(value);
+ if (i <= 0) {
+ throw new NumberFormatException("Value not positive.");
+ }
+ return i;
+ } catch (NumberFormatException e) {
+ LOGGER.log(Level.CONFIG,
+ "Value of 'jersey.config.test.container.port'"
+ + " property is not a valid positive integer [" + value + "]."
+ + " Reverting to default [" + DEFAULT_PORT + "].",
+ e);
+ }
+ }
+ return DEFAULT_PORT;
+ }
+
+ private volatile Server server;
+
+ public UriBuilder getUri() {
+ return UriBuilder.fromUri("http://localhost").port(getPort()).path(CONTEXT);
+ }
+
+ public void startServer(Class... resources) {
+ ResourceConfig config = new ResourceConfig(resources);
+ config.register(new LoggingFeature(LOGGER, LoggingFeature.Verbosity.PAYLOAD_ANY));
+ final URI baseUri = getBaseUri();
+ server = JettyHttpContainerFactory.createServer(baseUri, config);
+ LOGGER.log(Level.INFO, "Jetty-http server started on base uri: " + baseUri);
+ }
+
+ public void startServer(ResourceConfig config) {
+ final URI baseUri = getBaseUri();
+ server = JettyHttpContainerFactory.createServer(baseUri, config);
+ LOGGER.log(Level.INFO, "Jetty-http server started on base uri: " + baseUri);
+ }
+
+ public URI getBaseUri() {
+ return UriBuilder.fromUri("http://localhost/").port(getPort()).build();
+ }
+
+ public void stopServer() {
+ try {
+ server.stop();
+ server = null;
+ LOGGER.log(Level.INFO, "Jetty-http server stopped.");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @After
+ public void tearDown() {
+ if (server != null) {
+ stopServer();
+ }
+ }
+}
diff --git a/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AsyncTest.java b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AsyncTest.java
new file mode 100644
index 0000000..b4d6b81
--- /dev/null
+++ b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/AsyncTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.container.AsyncResponse;
+import javax.ws.rs.container.Suspended;
+import javax.ws.rs.container.TimeoutHandler;
+import javax.ws.rs.core.Response;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+/**
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ * @author Michal Gajdos
+ */
+public class AsyncTest extends AbstractJettyServerTester {
+
+ @Path("/async")
+ @SuppressWarnings("VoidMethodAnnotatedWithGET")
+ public static class AsyncResource {
+
+ public static AtomicInteger INVOCATION_COUNT = new AtomicInteger(0);
+
+ @GET
+ public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
+ new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ final String result = veryExpensiveOperation();
+ asyncResponse.resume(result);
+ }
+
+ private String veryExpensiveOperation() {
+ // ... very expensive operation that typically finishes within 5 seconds, simulated using sleep()
+ try {
+ Thread.sleep(5000);
+ } catch (final InterruptedException e) {
+ // ignore
+ }
+ return "DONE";
+ }
+ }).start();
+ }
+
+ @GET
+ @Path("timeout")
+ public void asyncGetWithTimeout(@Suspended final AsyncResponse asyncResponse) {
+ asyncResponse.setTimeoutHandler(new TimeoutHandler() {
+
+ @Override
+ public void handleTimeout(final AsyncResponse asyncResponse) {
+ asyncResponse.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE).entity("Operation time out.")
+ .build());
+ }
+ });
+ asyncResponse.setTimeout(3, TimeUnit.SECONDS);
+
+ new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ final String result = veryExpensiveOperation();
+ asyncResponse.resume(result);
+ }
+
+ private String veryExpensiveOperation() {
+ // ... very expensive operation that typically finishes within 10 seconds, simulated using sleep()
+ try {
+ Thread.sleep(7000);
+ } catch (final InterruptedException e) {
+ // ignore
+ }
+ return "DONE";
+ }
+ }).start();
+ }
+
+ @GET
+ @Path("multiple-invocations")
+ public void asyncMultipleInvocations(@Suspended final AsyncResponse asyncResponse) {
+ INVOCATION_COUNT.incrementAndGet();
+
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ asyncResponse.resume("OK");
+ }
+ }).start();
+ }
+ }
+
+ private Client client;
+
+ @Before
+ public void setUp() throws Exception {
+ startServer(AsyncResource.class);
+ client = ClientBuilder.newClient();
+ }
+
+ @Override
+ @After
+ public void tearDown() {
+ super.tearDown();
+ client = null;
+ }
+
+ @Test
+ public void testAsyncGet() throws ExecutionException, InterruptedException {
+ final Future<Response> responseFuture = client.target(getUri().path("/async")).request().async().get();
+ // Request is being processed asynchronously.
+ final Response response = responseFuture.get();
+ // get() waits for the response
+ assertEquals("DONE", response.readEntity(String.class));
+ }
+
+ @Test
+ public void testAsyncGetWithTimeout() throws ExecutionException, InterruptedException, TimeoutException {
+ final Future<Response> responseFuture = client.target(getUri().path("/async/timeout")).request().async().get();
+ // Request is being processed asynchronously.
+ final Response response = responseFuture.get();
+
+ // get() waits for the response
+ assertEquals(503, response.getStatus());
+ assertEquals("Operation time out.", response.readEntity(String.class));
+ }
+
+ /**
+ * JERSEY-2616 reproducer. Make sure resource method is only invoked once per one request.
+ */
+ @Test
+ public void testAsyncMultipleInvocations() throws Exception {
+ final Response response = client.target(getUri().path("/async/multiple-invocations")).request().get();
+
+ assertThat(AsyncResource.INVOCATION_COUNT.get(), is(1));
+
+ assertThat(response.getStatus(), is(200));
+ assertThat(response.readEntity(String.class), is("OK"));
+ }
+}
diff --git a/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/ExceptionTest.java b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/ExceptionTest.java
new file mode 100644
index 0000000..e934e6e
--- /dev/null
+++ b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/ExceptionTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import org.junit.Test;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Paul Sandoz
+ */
+public class ExceptionTest extends AbstractJettyServerTester {
+ @Path("{status}")
+ public static class ExceptionResource {
+ @GET
+ public String get(@PathParam("status") int status) {
+ throw new WebApplicationException(status);
+ }
+
+ }
+
+ @Test
+ public void test400StatusCode() throws IOException {
+ startServer(ExceptionResource.class);
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("400").build());
+ assertEquals(400, r.request().get(Response.class).getStatus());
+ }
+
+ @Test
+ public void test500StatusCode() {
+ startServer(ExceptionResource.class);
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("500").build());
+
+ assertEquals(500, r.request().get(Response.class).getStatus());
+ }
+}
diff --git a/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/LifecycleListenerTest.java b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/LifecycleListenerTest.java
new file mode 100644
index 0000000..1377b88
--- /dev/null
+++ b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/LifecycleListenerTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.AbstractContainerLifecycleListener;
+import org.glassfish.jersey.server.spi.Container;
+import org.junit.Test;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+
+/**
+ * Reload and ContainerLifecycleListener support test.
+ *
+ * @author Paul Sandoz
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class LifecycleListenerTest extends AbstractJettyServerTester {
+
+ @Path("/one")
+ public static class One {
+ @GET
+ public String get() {
+ return "one";
+ }
+ }
+
+ @Path("/two")
+ public static class Two {
+ @GET
+ public String get() {
+ return "two";
+ }
+ }
+
+ public static class Reloader extends AbstractContainerLifecycleListener {
+ Container container;
+
+ public void reload(ResourceConfig newConfig) {
+ container.reload(newConfig);
+ }
+
+ public void reload() {
+ container.reload();
+ }
+
+ @Override
+ public void onStartup(Container container) {
+ this.container = container;
+ }
+
+ }
+
+ @Test
+ public void testReload() {
+ final ResourceConfig rc = new ResourceConfig(One.class);
+
+ Reloader reloader = new Reloader();
+ rc.registerInstances(reloader);
+
+ startServer(rc);
+
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("/").build());
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals(404, r.path("two").request().get(Response.class).getStatus());
+
+ // add Two resource
+ reloader.reload(new ResourceConfig(One.class, Two.class));
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals("two", r.path("two").request().get(String.class));
+ }
+
+ static class StartStopListener extends AbstractContainerLifecycleListener {
+ volatile boolean started;
+ volatile boolean stopped;
+
+ @Override
+ public void onStartup(Container container) {
+ started = true;
+ }
+
+ @Override
+ public void onShutdown(Container container) {
+ stopped = true;
+ }
+ }
+
+ @Test
+ public void testStartupShutdownHooks() {
+ final StartStopListener listener = new StartStopListener();
+
+ startServer(new ResourceConfig(One.class).register(listener));
+
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("/").build());
+
+ assertThat(r.path("one").request().get(String.class), equalTo("one"));
+ assertThat(r.path("two").request().get(Response.class).getStatus(), equalTo(404));
+
+ stopServer();
+
+ assertTrue("ContainerLifecycleListener.onStartup has not been called.", listener.started);
+ assertTrue("ContainerLifecycleListener.onShutdown has not been called.", listener.stopped);
+ }
+}
diff --git a/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/OptionsTest.java b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/OptionsTest.java
new file mode 100644
index 0000000..8866c33
--- /dev/null
+++ b/containers/jetty-http/src/test/java/org/glassfish/jersey/jetty/OptionsTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty;
+
+import org.junit.Test;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.Response;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class OptionsTest extends AbstractJettyServerTester {
+
+ @Path("helloworld")
+ public static class HelloWorldResource {
+ public static final String CLICHED_MESSAGE = "Hello World!";
+
+ @GET
+ @Produces("text/plain")
+ public String getHello() {
+ return CLICHED_MESSAGE;
+ }
+ }
+
+ @Test
+ public void testFooBarOptions() {
+ startServer(HelloWorldResource.class);
+ Client client = ClientBuilder.newClient();
+ Response response = client.target(getUri()).path("helloworld").request().header("Accept", "foo/bar").options();
+ assertEquals(200, response.getStatus());
+ final String allowHeader = response.getHeaderString("Allow");
+ _checkAllowContent(allowHeader);
+ assertEquals(0, response.getLength());
+ assertEquals("foo/bar", response.getMediaType().toString());
+ }
+
+ private void _checkAllowContent(final String content) {
+ assertTrue(content.contains("GET"));
+ assertTrue(content.contains("HEAD"));
+ assertTrue(content.contains("OPTIONS"));
+ }
+
+}
diff --git a/containers/jetty-servlet/pom.xml b/containers/jetty-servlet/pom.xml
new file mode 100644
index 0000000..8ddf7b4
--- /dev/null
+++ b/containers/jetty-servlet/pom.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-jetty-servlet</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-jetty-servlet</name>
+
+ <description>Jetty Servlet Container</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>jersey-container-servlet</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>jersey-container-jetty-http</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-webapp</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Import-Package>
+ javax.servlet.*;version="[2.4,5.0)",
+ *
+ </Import-Package>
+ </instructions>
+ <unpackBundle>true</unpackBundle>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/JettyWebContainerFactory.java b/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/JettyWebContainerFactory.java
new file mode 100644
index 0000000..dd585ce
--- /dev/null
+++ b/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/JettyWebContainerFactory.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.jetty.servlet;
+
+import java.net.URI;
+import java.util.Map;
+
+import javax.servlet.Servlet;
+
+import org.glassfish.jersey.jetty.JettyHttpContainerFactory;
+import org.glassfish.jersey.servlet.ServletContainer;
+import org.glassfish.jersey.uri.UriComponent;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.eclipse.jetty.webapp.Configuration;
+import org.eclipse.jetty.webapp.WebAppContext;
+import org.eclipse.jetty.webapp.WebXmlConfiguration;
+
+/**
+ * Factory for creating and starting Jetty {@link Server} instances
+ * for deploying a Servlet.
+ * <p/>
+ * The default deployed server is an instance of {@link ServletContainer}.
+ * <p/>
+ * If no initialization parameters are declared (or is null) then root
+ * resource and provider classes will be found by searching the classes
+ * referenced in the java classpath.
+ *
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ */
+public final class JettyWebContainerFactory {
+
+ private JettyWebContainerFactory() {
+ }
+
+ /**
+ * Create a {@link Server} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(String u)
+ throws Exception {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u));
+ }
+
+ /**
+ * Create a {@link Server} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(String u, Map<String, String> initParams)
+ throws Exception {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), initParams);
+ }
+
+ /**
+ * Create a {@link Server} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(URI u)
+ throws Exception {
+ return create(u, ServletContainer.class);
+ }
+
+ /**
+ * Create a {@link Server} that registers the {@link ServletContainer}.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(URI u, Map<String, String> initParams)
+ throws Exception {
+ return create(u, ServletContainer.class, initParams);
+ }
+
+ /**
+ * Create a {@link Server} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(String u, Class<? extends Servlet> c)
+ throws Exception {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), c);
+ }
+
+ /**
+ * Create a {@link Server} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(String u, Class<? extends Servlet> c,
+ Map<String, String> initParams)
+ throws Exception {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ return create(URI.create(u), c, initParams);
+ }
+
+ /**
+ * Create a {@link Server} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(URI u, Class<? extends Servlet> c)
+ throws Exception {
+ return create(u, c, null);
+ }
+
+ /**
+ * Create a {@link Server} that registers the declared
+ * servlet class.
+ *
+ * @param u the URI to create the http server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param c the servlet class.
+ * @param initParams the servlet initialization parameters.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(URI u, Class<? extends Servlet> c, Map<String, String> initParams)
+ throws Exception {
+ return create(u, c, null, initParams, null);
+ }
+
+ private static Server create(URI u, Class<? extends Servlet> c, Servlet servlet,
+ Map<String, String> initParams, Map<String, String> contextInitParams)
+ throws Exception {
+ if (u == null) {
+ throw new IllegalArgumentException("The URI must not be null");
+ }
+
+ String path = u.getPath();
+ if (path == null) {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ", must be non-null");
+ } else if (path.isEmpty()) {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ", must be present");
+ } else if (path.charAt(0) != '/') {
+ throw new IllegalArgumentException("The URI path, of the URI " + u + ". must start with a '/'");
+ }
+
+ path = String.format("/%s", UriComponent.decodePath(u.getPath(), true).get(1).toString());
+ WebAppContext context = new WebAppContext();
+ context.setDisplayName("JettyContext");
+ context.setContextPath(path);
+ context.setConfigurations(new Configuration[]{new WebXmlConfiguration()});
+ ServletHolder holder;
+ if (c != null) {
+ holder = context.addServlet(c, "/*");
+ } else {
+ holder = new ServletHolder(servlet);
+ context.addServlet(holder, "/*");
+ }
+
+ if (contextInitParams != null) {
+ for (Map.Entry<String, String> e : contextInitParams.entrySet()) {
+ context.setInitParameter(e.getKey(), e.getValue());
+ }
+ }
+
+ if (initParams != null) {
+ holder.setInitParameters(initParams);
+ }
+
+ Server server = JettyHttpContainerFactory.createServer(u, false);
+ server.setHandler(context);
+ server.start();
+ return server;
+ }
+
+ /**
+ * Create a {@link Server} that registers the declared
+ * servlet instance.
+ *
+ * @param u the URI to create the HTTP server. The URI scheme must be
+ * equal to "http". The URI user information and host
+ * are ignored If the URI port is not present then port 80 will be
+ * used. The URI query and fragment components are ignored. Only first path segment will be used
+ * as context path, the rest will be ignored.
+ * @param servlet the servlet instance.
+ * @param initParams the servlet initialization parameters.
+ * @param contextInitParams the servlet context initialization parameters.
+ * @return the http server, with the endpoint started.
+ * @throws Exception if an error occurs creating the container.
+ * @throws IllegalArgumentException if HTTP server URI is {@code null}.
+ */
+ public static Server create(URI u, Servlet servlet, Map<String, String> initParams, Map<String, String> contextInitParams)
+ throws Exception {
+ if (servlet == null) {
+ throw new IllegalArgumentException("The servlet must not be null");
+ }
+ return create(u, null, servlet, initParams, contextInitParams);
+ }
+}
diff --git a/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/package-info.java b/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/package-info.java
new file mode 100644
index 0000000..0a643c3
--- /dev/null
+++ b/containers/jetty-servlet/src/main/java/org/glassfish/jersey/jetty/servlet/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey Jetty Servlet container classes.
+ */
+package org.glassfish.jersey.jetty.servlet;
diff --git a/containers/netty-http/pom.xml b/containers/netty-http/pom.xml
new file mode 100644
index 0000000..beb0545
--- /dev/null
+++ b/containers/netty-http/pom.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-netty-http</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-netty-http</name>
+
+ <description>Netty Http Container.</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.connectors</groupId>
+ <artifactId>jersey-netty-connector</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/HttpVersionChooser.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/HttpVersionChooser.java
new file mode 100644
index 0000000..22660e2
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/HttpVersionChooser.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.net.URI;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.HttpServerCodec;
+import io.netty.handler.codec.http2.Http2Codec;
+import io.netty.handler.ssl.ApplicationProtocolNames;
+import io.netty.handler.ssl.ApplicationProtocolNegotiationHandler;
+import io.netty.handler.stream.ChunkedWriteHandler;
+
+/**
+ * Choose the handler implementation based on Http protocol.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class HttpVersionChooser extends ApplicationProtocolNegotiationHandler {
+
+ private final URI baseUri;
+ private final NettyHttpContainer container;
+
+ HttpVersionChooser(URI baseUri, NettyHttpContainer container) {
+ super(ApplicationProtocolNames.HTTP_1_1);
+
+ this.baseUri = baseUri;
+ this.container = container;
+ }
+
+ @Override
+ protected void configurePipeline(ChannelHandlerContext ctx, String protocol) throws Exception {
+ if (ApplicationProtocolNames.HTTP_2.equals(protocol)) {
+ ctx.pipeline().addLast(new Http2Codec(true, new JerseyHttp2ServerHandler(baseUri, container)));
+ return;
+ }
+
+ if (ApplicationProtocolNames.HTTP_1_1.equals(protocol)) {
+ ctx.pipeline().addLast(new HttpServerCodec(),
+ new ChunkedWriteHandler(),
+ new JerseyServerHandler(baseUri, container));
+ return;
+ }
+
+ throw new IllegalStateException("Unknown protocol: " + protocol);
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyHttp2ServerHandler.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyHttp2ServerHandler.java
new file mode 100644
index 0000000..ddb1089
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyHttp2ServerHandler.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.security.Principal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.LinkedBlockingDeque;
+
+import javax.ws.rs.core.SecurityContext;
+
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http2.Http2DataFrame;
+import io.netty.handler.codec.http2.Http2HeadersFrame;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import org.glassfish.jersey.internal.PropertiesDelegate;
+import org.glassfish.jersey.netty.connector.internal.NettyInputStream;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+
+/**
+ * Jersey Netty HTTP/2 handler.
+ * <p>
+ * Note that this implementation cannot be more experimental. Any contributions / feedback is welcomed.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+@ChannelHandler.Sharable
+class JerseyHttp2ServerHandler extends ChannelDuplexHandler {
+
+ private final URI baseUri;
+ private final LinkedBlockingDeque<InputStream> isList = new LinkedBlockingDeque<>();
+ private final NettyHttpContainer container;
+
+ /**
+ * Constructor.
+ *
+ * @param baseUri base {@link URI} of the container (includes context path, if any).
+ * @param container Netty container implementation.
+ */
+ JerseyHttp2ServerHandler(URI baseUri, NettyHttpContainer container) {
+ this.baseUri = baseUri;
+ this.container = container;
+ }
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+ ctx.close();
+ }
+
+ @Override
+ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+ if (msg instanceof Http2HeadersFrame) {
+ onHeadersRead(ctx, (Http2HeadersFrame) msg);
+ } else if (msg instanceof Http2DataFrame) {
+ onDataRead(ctx, (Http2DataFrame) msg);
+ } else {
+ super.channelRead(ctx, msg);
+ }
+ }
+
+ /**
+ * Process incoming data.
+ */
+ private void onDataRead(ChannelHandlerContext ctx, Http2DataFrame data) throws Exception {
+ isList.add(new ByteBufInputStream(data.content()));
+ if (data.isEndStream()) {
+ isList.add(NettyInputStream.END_OF_INPUT);
+ }
+ }
+
+ /**
+ * Process incoming request (just a headers in this case, entity is processed separately).
+ */
+ private void onHeadersRead(ChannelHandlerContext ctx, Http2HeadersFrame headers) throws Exception {
+
+ final ContainerRequest requestContext = createContainerRequest(ctx, headers);
+
+ requestContext.setWriter(new NettyHttp2ResponseWriter(ctx, headers, container));
+
+ // must be like this, since there is a blocking read from Jersey
+ container.getExecutorService().execute(new Runnable() {
+ @Override
+ public void run() {
+ container.getApplicationHandler().handle(requestContext);
+ }
+ });
+ }
+
+ /**
+ * Create Jersey {@link ContainerRequest} based on Netty {@link HttpRequest}.
+ *
+ * @param ctx Netty channel context.
+ * @param http2Headers Netty Http/2 headers.
+ * @return created Jersey Container Request.
+ */
+ private ContainerRequest createContainerRequest(ChannelHandlerContext ctx, Http2HeadersFrame http2Headers) {
+
+ String path = http2Headers.headers().path().toString();
+
+ String s = path.startsWith("/") ? path.substring(1) : path;
+ URI requestUri = URI.create(baseUri + ContainerUtils.encodeUnsafeCharacters(s));
+
+ ContainerRequest requestContext = new ContainerRequest(
+ baseUri, requestUri, http2Headers.headers().method().toString(), getSecurityContext(),
+ new PropertiesDelegate() {
+
+ private final Map<String, Object> properties = new HashMap<>();
+
+ @Override
+ public Object getProperty(String name) {
+ return properties.get(name);
+ }
+
+ @Override
+ public Collection<String> getPropertyNames() {
+ return properties.keySet();
+ }
+
+ @Override
+ public void setProperty(String name, Object object) {
+ properties.put(name, object);
+ }
+
+ @Override
+ public void removeProperty(String name) {
+ properties.remove(name);
+ }
+ });
+
+ // request entity handling.
+ if (!http2Headers.isEndStream()) {
+
+ ctx.channel().closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() {
+ @Override
+ public void operationComplete(Future<? super Void> future) throws Exception {
+ isList.add(NettyInputStream.END_OF_INPUT_ERROR);
+ }
+ });
+
+ requestContext.setEntityStream(new NettyInputStream(isList));
+ } else {
+ requestContext.setEntityStream(new InputStream() {
+ @Override
+ public int read() throws IOException {
+ return -1;
+ }
+ });
+ }
+
+ // copying headers from netty request to jersey container request context.
+ for (CharSequence name : http2Headers.headers().names()) {
+ requestContext.headers(name.toString(), mapToString(http2Headers.headers().getAll(name)));
+ }
+
+ return requestContext;
+ }
+
+ private List<String> mapToString(List<CharSequence> list) {
+ ArrayList<String> result = new ArrayList<>(list.size());
+
+ for (CharSequence sequence : list) {
+ result.add(sequence.toString());
+ }
+
+ return result;
+ }
+
+ private SecurityContext getSecurityContext() {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return false;
+ }
+
+ @Override
+ public boolean isSecure() {
+ return false;
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return null;
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return null;
+ }
+ };
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerHandler.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerHandler.java
new file mode 100644
index 0000000..33437e2
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerHandler.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.security.Principal;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.LinkedBlockingDeque;
+
+import javax.ws.rs.core.SecurityContext;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.codec.http.DefaultFullHttpResponse;
+import io.netty.handler.codec.http.HttpContent;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.HttpUtil;
+import io.netty.handler.codec.http.HttpVersion;
+import io.netty.handler.codec.http.LastHttpContent;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import org.glassfish.jersey.internal.PropertiesDelegate;
+import org.glassfish.jersey.netty.connector.internal.NettyInputStream;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+
+/**
+ * {@link io.netty.channel.ChannelInboundHandler} which servers as a bridge
+ * between Netty and Jersey.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class JerseyServerHandler extends ChannelInboundHandlerAdapter {
+
+ private final URI baseUri;
+ private final LinkedBlockingDeque<InputStream> isList = new LinkedBlockingDeque<>();
+ private final NettyHttpContainer container;
+
+ /**
+ * Constructor.
+ *
+ * @param baseUri base {@link URI} of the container (includes context path, if any).
+ * @param container Netty container implementation.
+ */
+ public JerseyServerHandler(URI baseUri, NettyHttpContainer container) {
+ this.baseUri = baseUri;
+ this.container = container;
+ }
+
+ @Override
+ public void channelRead(final ChannelHandlerContext ctx, Object msg) {
+
+ if (msg instanceof HttpRequest) {
+ final HttpRequest req = (HttpRequest) msg;
+
+ if (HttpUtil.is100ContinueExpected(req)) {
+ ctx.write(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE));
+ }
+
+ isList.clear(); // clearing the content - possible leftover from previous request processing.
+ final ContainerRequest requestContext = createContainerRequest(ctx, req);
+
+ requestContext.setWriter(new NettyResponseWriter(ctx, req, container));
+
+ // must be like this, since there is a blocking read from Jersey
+ container.getExecutorService().execute(new Runnable() {
+ @Override
+ public void run() {
+ container.getApplicationHandler().handle(requestContext);
+ }
+ });
+ }
+
+ if (msg instanceof HttpContent) {
+ HttpContent httpContent = (HttpContent) msg;
+
+ ByteBuf content = httpContent.content();
+
+ if (content.isReadable()) {
+ isList.add(new ByteBufInputStream(content));
+ }
+
+ if (msg instanceof LastHttpContent) {
+ isList.add(NettyInputStream.END_OF_INPUT);
+ }
+ }
+ }
+
+ /**
+ * Create Jersey {@link ContainerRequest} based on Netty {@link HttpRequest}.
+ *
+ * @param ctx Netty channel context.
+ * @param req Netty Http request.
+ * @return created Jersey Container Request.
+ */
+ private ContainerRequest createContainerRequest(ChannelHandlerContext ctx, HttpRequest req) {
+
+ String s = req.uri().startsWith("/") ? req.uri().substring(1) : req.uri();
+ URI requestUri = URI.create(baseUri + ContainerUtils.encodeUnsafeCharacters(s));
+
+ ContainerRequest requestContext = new ContainerRequest(
+ baseUri, requestUri, req.method().name(), getSecurityContext(),
+ new PropertiesDelegate() {
+
+ private final Map<String, Object> properties = new HashMap<>();
+
+ @Override
+ public Object getProperty(String name) {
+ return properties.get(name);
+ }
+
+ @Override
+ public Collection<String> getPropertyNames() {
+ return properties.keySet();
+ }
+
+ @Override
+ public void setProperty(String name, Object object) {
+ properties.put(name, object);
+ }
+
+ @Override
+ public void removeProperty(String name) {
+ properties.remove(name);
+ }
+ });
+
+ // request entity handling.
+ if ((req.headers().contains(HttpHeaderNames.CONTENT_LENGTH) && HttpUtil.getContentLength(req) > 0)
+ || HttpUtil.isTransferEncodingChunked(req)) {
+
+ ctx.channel().closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() {
+ @Override
+ public void operationComplete(Future<? super Void> future) throws Exception {
+ isList.add(NettyInputStream.END_OF_INPUT_ERROR);
+ }
+ });
+
+ requestContext.setEntityStream(new NettyInputStream(isList));
+ } else {
+ requestContext.setEntityStream(new InputStream() {
+ @Override
+ public int read() throws IOException {
+ return -1;
+ }
+ });
+ }
+
+ // copying headers from netty request to jersey container request context.
+ for (String name : req.headers().names()) {
+ requestContext.headers(name, req.headers().getAll(name));
+ }
+
+ return requestContext;
+ }
+
+ private SecurityContext getSecurityContext() {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return false;
+ }
+
+ @Override
+ public boolean isSecure() {
+ return false;
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return null;
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return null;
+ }
+ };
+ }
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+ ctx.close();
+ }
+
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerInitializer.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerInitializer.java
new file mode 100644
index 0000000..16a6ce0
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/JerseyServerInitializer.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.net.URI;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.http.HttpMessage;
+import io.netty.handler.codec.http.HttpServerCodec;
+import io.netty.handler.codec.http.HttpServerUpgradeHandler;
+import io.netty.handler.codec.http2.Http2Codec;
+import io.netty.handler.codec.http2.Http2CodecUtil;
+import io.netty.handler.codec.http2.Http2ServerUpgradeCodec;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.stream.ChunkedWriteHandler;
+import io.netty.util.AsciiString;
+
+/**
+ * Jersey {@link ChannelInitializer}.
+ * <p>
+ * Adds {@link HttpServerCodec}, {@link ChunkedWriteHandler} and {@link JerseyServerHandler} to the channels pipeline.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class JerseyServerInitializer extends ChannelInitializer<SocketChannel> {
+
+ private final URI baseUri;
+ private final SslContext sslCtx;
+ private final NettyHttpContainer container;
+ private final boolean http2;
+
+ /**
+ * Constructor.
+ *
+ * @param baseUri base {@link URI} of the container (includes context path, if any).
+ * @param sslCtx SSL context.
+ * @param container Netty container implementation.
+ */
+ public JerseyServerInitializer(URI baseUri, SslContext sslCtx, NettyHttpContainer container) {
+ this(baseUri, sslCtx, container, false);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param baseUri base {@link URI} of the container (includes context path, if any).
+ * @param sslCtx SSL context.
+ * @param container Netty container implementation.
+ * @param http2 Http/2 protocol support.
+ */
+ public JerseyServerInitializer(URI baseUri, SslContext sslCtx, NettyHttpContainer container, boolean http2) {
+ this.baseUri = baseUri;
+ this.sslCtx = sslCtx;
+ this.container = container;
+ this.http2 = http2;
+ }
+
+ @Override
+ public void initChannel(SocketChannel ch) {
+ if (http2) {
+
+ if (sslCtx != null) {
+ configureSsl(ch);
+ } else {
+ configureClearText(ch);
+ }
+
+ } else {
+ ChannelPipeline p = ch.pipeline();
+ if (sslCtx != null) {
+ p.addLast(sslCtx.newHandler(ch.alloc()));
+ }
+ p.addLast(new HttpServerCodec());
+ p.addLast(new ChunkedWriteHandler());
+ p.addLast(new JerseyServerHandler(baseUri, container));
+ }
+ }
+
+ /**
+ * Configure the pipeline for TLS NPN negotiation to HTTP/2.
+ */
+ private void configureSsl(SocketChannel ch) {
+ ch.pipeline().addLast(sslCtx.newHandler(ch.alloc()), new HttpVersionChooser(baseUri, container));
+ }
+
+ /**
+ * Configure the pipeline for a cleartext upgrade from HTTP to HTTP/2.
+ */
+ private void configureClearText(SocketChannel ch) {
+ final ChannelPipeline p = ch.pipeline();
+ final HttpServerCodec sourceCodec = new HttpServerCodec();
+
+ p.addLast(sourceCodec);
+ p.addLast(new HttpServerUpgradeHandler(sourceCodec, new HttpServerUpgradeHandler.UpgradeCodecFactory() {
+ @Override
+ public HttpServerUpgradeHandler.UpgradeCodec newUpgradeCodec(CharSequence protocol) {
+ if (AsciiString.contentEquals(Http2CodecUtil.HTTP_UPGRADE_PROTOCOL_NAME, protocol)) {
+ return new Http2ServerUpgradeCodec(new Http2Codec(true, new JerseyHttp2ServerHandler(baseUri, container)));
+ } else {
+ return null;
+ }
+ }
+ }));
+ p.addLast(new SimpleChannelInboundHandler<HttpMessage>() {
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, HttpMessage msg) throws Exception {
+ // If this handler is hit then no upgrade has been attempted and the client is just talking HTTP.
+ // "Directly talking: " + msg.protocolVersion() + " (no upgrade was attempted)");
+
+ ChannelPipeline pipeline = ctx.pipeline();
+ ChannelHandlerContext thisCtx = pipeline.context(this);
+ pipeline.addAfter(thisCtx.name(), null, new JerseyServerHandler(baseUri, container));
+ pipeline.replace(this, null, new ChunkedWriteHandler());
+ ctx.fireChannelRead(msg);
+ }
+ });
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttp2ResponseWriter.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttp2ResponseWriter.java
new file mode 100644
index 0000000..327d894
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttp2ResponseWriter.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.DefaultFullHttpResponse;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http2.DefaultHttp2DataFrame;
+import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersFrame;
+import io.netty.handler.codec.http2.Http2HeadersFrame;
+
+/**
+ * Netty implementation of {@link ContainerResponseWriter}.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class NettyHttp2ResponseWriter implements ContainerResponseWriter {
+
+ private final ChannelHandlerContext ctx;
+ private final Http2HeadersFrame headersFrame;
+ private final NettyHttpContainer container;
+
+ private volatile ScheduledFuture<?> suspendTimeoutFuture;
+ private volatile Runnable suspendTimeoutHandler;
+
+ NettyHttp2ResponseWriter(ChannelHandlerContext ctx, Http2HeadersFrame headersFrame, NettyHttpContainer container) {
+ this.ctx = ctx;
+ this.headersFrame = headersFrame;
+ this.container = container;
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext)
+ throws ContainerException {
+
+ String reasonPhrase = responseContext.getStatusInfo().getReasonPhrase();
+ int statusCode = responseContext.getStatus();
+
+ HttpResponseStatus status = reasonPhrase == null
+ ? HttpResponseStatus.valueOf(statusCode)
+ : new HttpResponseStatus(statusCode, reasonPhrase);
+
+ DefaultHttp2Headers response = new DefaultHttp2Headers();
+ response.status(Integer.toString(responseContext.getStatus()));
+
+ for (final Map.Entry<String, List<String>> e : responseContext.getStringHeaders().entrySet()) {
+ response.add(e.getKey().toLowerCase(), e.getValue());
+ }
+
+ response.set(HttpHeaderNames.CONTENT_LENGTH, Long.toString(contentLength));
+
+ ctx.writeAndFlush(new DefaultHttp2HeadersFrame(response));
+
+ if (!headersFrame.headers().method().equals(HttpMethod.HEAD.asciiName())
+ && (contentLength > 0 || contentLength == -1)) {
+
+ return new OutputStream() {
+ @Override
+ public void write(int b) throws IOException {
+ write(new byte[]{(byte) b});
+ }
+
+ @Override
+ public void write(byte[] b) throws IOException {
+ write(b, 0, b.length);
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+
+ ByteBuf buffer = ctx.alloc().buffer(len);
+ buffer.writeBytes(b, off, len);
+
+ ctx.writeAndFlush(new DefaultHttp2DataFrame(buffer, false));
+ }
+
+ @Override
+ public void flush() throws IOException {
+ ctx.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ ctx.write(new DefaultHttp2DataFrame(true)).addListener(NettyResponseWriter.FLUSH_FUTURE);
+ }
+ };
+
+ } else {
+ ctx.writeAndFlush(new DefaultHttp2DataFrame(true));
+ return null;
+ }
+ }
+
+ @Override
+ public boolean suspend(long timeOut, TimeUnit timeUnit, final ContainerResponseWriter.TimeoutHandler
+ timeoutHandler) {
+
+ suspendTimeoutHandler = new Runnable() {
+ @Override
+ public void run() {
+ timeoutHandler.onTimeout(NettyHttp2ResponseWriter.this);
+ }
+ };
+
+ if (timeOut <= 0) {
+ return true;
+ }
+
+ suspendTimeoutFuture =
+ container.getScheduledExecutorService().schedule(suspendTimeoutHandler, timeOut, timeUnit);
+
+ return true;
+ }
+
+ @Override
+ public void setSuspendTimeout(long timeOut, TimeUnit timeUnit) throws IllegalStateException {
+
+ // suspend(0, .., ..) was called, so suspendTimeoutFuture is null.
+ if (suspendTimeoutFuture != null) {
+ suspendTimeoutFuture.cancel(true);
+ }
+
+ if (timeOut <= 0) {
+ return;
+ }
+
+ suspendTimeoutFuture =
+ container.getScheduledExecutorService().schedule(suspendTimeoutHandler, timeOut, timeUnit);
+ }
+
+ @Override
+ public void commit() {
+ ctx.flush();
+ }
+
+ @Override
+ public void failure(Throwable error) {
+ ctx.writeAndFlush(new DefaultHttp2Headers().status(HttpResponseStatus.INTERNAL_SERVER_ERROR.codeAsText()))
+ .addListener(ChannelFutureListener.CLOSE);
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return true;
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainer.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainer.java
new file mode 100644
index 0000000..c825a82
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainer.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+
+import javax.ws.rs.core.Application;
+
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.spi.ExecutorServiceProvider;
+import org.glassfish.jersey.spi.ScheduledExecutorServiceProvider;
+
+/**
+ * Netty based implementation of a {@link Container}.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class NettyHttpContainer implements Container {
+
+ private volatile ApplicationHandler appHandler;
+
+ public NettyHttpContainer(Application application) {
+ this.appHandler = new ApplicationHandler(application);
+ this.appHandler.onStartup(this);
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return appHandler.getConfiguration();
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return appHandler;
+ }
+
+ @Override
+ public void reload() {
+ reload(appHandler.getConfiguration());
+ }
+
+ @Override
+ public void reload(ResourceConfig configuration) {
+ appHandler.onShutdown(this);
+
+ appHandler = new ApplicationHandler(configuration);
+ appHandler.onReload(this);
+ appHandler.onStartup(this);
+ }
+
+ /**
+ * Get {@link java.util.concurrent.ExecutorService}.
+ *
+ * @return Executor service associated with this container.
+ */
+ ExecutorService getExecutorService() {
+ return appHandler.getInjectionManager().getInstance(ExecutorServiceProvider.class).getExecutorService();
+ }
+
+ /**
+ * Get {@link ScheduledExecutorService}.
+ *
+ * @return Scheduled executor service associated with this container.
+ */
+ ScheduledExecutorService getScheduledExecutorService() {
+ return appHandler.getInjectionManager().getInstance(ScheduledExecutorServiceProvider.class).getExecutorService();
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainerProvider.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainerProvider.java
new file mode 100644
index 0000000..124b36e
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyHttpContainerProvider.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.net.URI;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Application;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.handler.ssl.SslContext;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import org.glassfish.jersey.Beta;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.ContainerProvider;
+
+/**
+ * Netty implementation of {@link ContainerProvider}.
+ * <p>
+ * There is also a few "factory" methods for creating Netty server.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ * @since 2.24
+ */
+@Beta
+public class NettyHttpContainerProvider implements ContainerProvider {
+
+ @Override
+ public <T> T createContainer(Class<T> type, Application application) throws ProcessingException {
+ if (NettyHttpContainer.class == type) {
+ return type.cast(new NettyHttpContainer(application));
+ }
+
+ return null;
+ }
+
+ /**
+ * Create and start Netty server.
+ *
+ * @param baseUri base uri.
+ * @param configuration Jersey configuration.
+ * @param sslContext Netty SSL context (can be null).
+ * @param block when {@code true}, this method will block until the server is stopped. When {@code false}, the
+ * execution will
+ * end immediately after the server is started.
+ * @return Netty channel instance.
+ * @throws ProcessingException when there is an issue with creating new container.
+ */
+ public static Channel createServer(final URI baseUri, final ResourceConfig configuration, SslContext sslContext,
+ final boolean block)
+ throws ProcessingException {
+
+ // Configure the server.
+ final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
+ final EventLoopGroup workerGroup = new NioEventLoopGroup();
+ final NettyHttpContainer container = new NettyHttpContainer(configuration);
+
+ try {
+ ServerBootstrap b = new ServerBootstrap();
+ b.option(ChannelOption.SO_BACKLOG, 1024);
+ b.group(bossGroup, workerGroup)
+ .channel(NioServerSocketChannel.class)
+ .childHandler(new JerseyServerInitializer(baseUri, sslContext, container));
+
+ int port = getPort(baseUri);
+
+ Channel ch = b.bind(port).sync().channel();
+
+ ch.closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() {
+ @Override
+ public void operationComplete(Future<? super Void> future) throws Exception {
+ container.getApplicationHandler().onShutdown(container);
+
+ bossGroup.shutdownGracefully();
+ workerGroup.shutdownGracefully();
+ }
+ });
+
+ if (block) {
+ ch.closeFuture().sync();
+ return ch;
+ } else {
+ return ch;
+ }
+ } catch (InterruptedException e) {
+ throw new ProcessingException(e);
+ }
+ }
+
+ /**
+ * Create and start Netty server.
+ *
+ * @param baseUri base uri.
+ * @param configuration Jersey configuration.
+ * @param block when {@code true}, this method will block until the server is stopped. When {@code false}, the
+ * execution will
+ * end immediately after the server is started.
+ * @return Netty channel instance.
+ * @throws ProcessingException when there is an issue with creating new container.
+ */
+ public static Channel createServer(final URI baseUri, final ResourceConfig configuration, final boolean block)
+ throws ProcessingException {
+
+ return createServer(baseUri, configuration, null, block);
+ }
+
+ /**
+ * Create and start Netty HTTP/2 server.
+ * <p>
+ * The server is capable of connection upgrade to HTTP/2. HTTP/1.x request will be server as they were used to.
+ * <p>
+ * Note that this implementation cannot be more experimental. Any contributions / feedback is welcomed.
+ *
+ * @param baseUri base uri.
+ * @param configuration Jersey configuration.
+ * @param sslContext Netty {@link SslContext}.
+ * @return Netty channel instance.
+ * @throws ProcessingException when there is an issue with creating new container.
+ */
+ public static Channel createHttp2Server(final URI baseUri, final ResourceConfig configuration, SslContext sslContext) throws
+ ProcessingException {
+
+ final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
+ final EventLoopGroup workerGroup = new NioEventLoopGroup();
+ final NettyHttpContainer container = new NettyHttpContainer(configuration);
+
+ try {
+ ServerBootstrap b = new ServerBootstrap();
+ b.option(ChannelOption.SO_BACKLOG, 1024);
+ b.group(bossGroup, workerGroup)
+ .channel(NioServerSocketChannel.class)
+ .childHandler(new JerseyServerInitializer(baseUri, sslContext, container, true));
+
+ int port = getPort(baseUri);
+
+ Channel ch = b.bind(port).sync().channel();
+
+ ch.closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() {
+ @Override
+ public void operationComplete(Future<? super Void> future) throws Exception {
+ container.getApplicationHandler().onShutdown(container);
+
+ bossGroup.shutdownGracefully();
+ workerGroup.shutdownGracefully();
+ }
+ });
+
+ return ch;
+
+ } catch (InterruptedException e) {
+ throw new ProcessingException(e);
+ }
+ }
+
+ private static int getPort(URI uri) {
+ if (uri.getPort() == -1) {
+ if ("http".equalsIgnoreCase(uri.getScheme())) {
+ return 80;
+ } else if ("https".equalsIgnoreCase(uri.getScheme())) {
+ return 443;
+ }
+
+ throw new IllegalArgumentException("URI scheme must be 'http' or 'https'.");
+ }
+
+ return uri.getPort();
+ }
+}
diff --git a/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyResponseWriter.java b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyResponseWriter.java
new file mode 100644
index 0000000..e50d870
--- /dev/null
+++ b/containers/netty-http/src/main/java/org/glassfish/jersey/netty/httpserver/NettyResponseWriter.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2016, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.netty.httpserver;
+
+import java.io.OutputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.glassfish.jersey.netty.connector.internal.JerseyChunkedInput;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.DefaultFullHttpResponse;
+import io.netty.handler.codec.http.DefaultHttpResponse;
+import io.netty.handler.codec.http.HttpChunkedInput;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpHeaderValues;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.HttpUtil;
+import io.netty.handler.codec.http.LastHttpContent;
+
+/**
+ * Netty implementation of {@link ContainerResponseWriter}.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+class NettyResponseWriter implements ContainerResponseWriter {
+
+ private static final Logger LOGGER = Logger.getLogger(NettyResponseWriter.class.getName());
+
+ static final ChannelFutureListener FLUSH_FUTURE = new ChannelFutureListener() {
+ @Override
+ public void operationComplete(ChannelFuture future) throws Exception {
+ future.channel().flush();
+ }
+ };
+
+ private final ChannelHandlerContext ctx;
+ private final HttpRequest req;
+ private final NettyHttpContainer container;
+
+ private volatile ScheduledFuture<?> suspendTimeoutFuture;
+ private volatile Runnable suspendTimeoutHandler;
+
+ private boolean responseWritten = false;
+
+ NettyResponseWriter(ChannelHandlerContext ctx, HttpRequest req, NettyHttpContainer container) {
+ this.ctx = ctx;
+ this.req = req;
+ this.container = container;
+ }
+
+ @Override
+ public synchronized OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext)
+ throws ContainerException {
+
+ if (responseWritten) {
+ LOGGER.log(Level.FINE, "Response already written.");
+ return null;
+ }
+
+ responseWritten = true;
+
+ String reasonPhrase = responseContext.getStatusInfo().getReasonPhrase();
+ int statusCode = responseContext.getStatus();
+
+ HttpResponseStatus status = reasonPhrase == null
+ ? HttpResponseStatus.valueOf(statusCode)
+ : new HttpResponseStatus(statusCode, reasonPhrase);
+
+ DefaultHttpResponse response;
+ if (contentLength == 0) {
+ response = new DefaultFullHttpResponse(req.protocolVersion(), status);
+ } else {
+ response = new DefaultHttpResponse(req.protocolVersion(), status);
+ }
+
+ for (final Map.Entry<String, List<String>> e : responseContext.getStringHeaders().entrySet()) {
+ response.headers().add(e.getKey(), e.getValue());
+ }
+
+ if (contentLength == -1) {
+ HttpUtil.setTransferEncodingChunked(response, true);
+ } else {
+ response.headers().set(HttpHeaderNames.CONTENT_LENGTH, contentLength);
+ }
+
+ if (HttpUtil.isKeepAlive(req)) {
+ response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
+ }
+
+ ctx.writeAndFlush(response);
+
+ if (req.method() != HttpMethod.HEAD && (contentLength > 0 || contentLength == -1)) {
+
+ JerseyChunkedInput jerseyChunkedInput = new JerseyChunkedInput(ctx.channel());
+
+ if (HttpUtil.isTransferEncodingChunked(response)) {
+ ctx.write(new HttpChunkedInput(jerseyChunkedInput)).addListener(FLUSH_FUTURE);
+ } else {
+ ctx.write(new HttpChunkedInput(jerseyChunkedInput)).addListener(FLUSH_FUTURE);
+ }
+ return jerseyChunkedInput;
+
+ } else {
+ ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
+ return null;
+ }
+ }
+
+ @Override
+ public boolean suspend(long timeOut, TimeUnit timeUnit, final ContainerResponseWriter.TimeoutHandler
+ timeoutHandler) {
+
+ suspendTimeoutHandler = new Runnable() {
+ @Override
+ public void run() {
+ timeoutHandler.onTimeout(NettyResponseWriter.this);
+ }
+ };
+
+ if (timeOut <= 0) {
+ return true;
+ }
+
+ suspendTimeoutFuture =
+ container.getScheduledExecutorService().schedule(suspendTimeoutHandler, timeOut, timeUnit);
+
+ return true;
+ }
+
+ @Override
+ public void setSuspendTimeout(long timeOut, TimeUnit timeUnit) throws IllegalStateException {
+
+ // suspend(0, .., ..) was called, so suspendTimeoutFuture is null.
+ if (suspendTimeoutFuture != null) {
+ suspendTimeoutFuture.cancel(true);
+ }
+
+ if (timeOut <= 0) {
+ return;
+ }
+
+ suspendTimeoutFuture =
+ container.getScheduledExecutorService().schedule(suspendTimeoutHandler, timeOut, timeUnit);
+ }
+
+ @Override
+ public void commit() {
+ ctx.flush();
+ }
+
+ @Override
+ public void failure(Throwable error) {
+ ctx.writeAndFlush(new DefaultFullHttpResponse(req.protocolVersion(), HttpResponseStatus.INTERNAL_SERVER_ERROR))
+ .addListener(ChannelFutureListener.CLOSE);
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return true;
+ }
+}
diff --git a/containers/netty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider b/containers/netty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
new file mode 100644
index 0000000..96ee927
--- /dev/null
+++ b/containers/netty-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.netty.httpserver.NettyHttpContainerProvider
diff --git a/containers/pom.xml b/containers/pom.xml
new file mode 100644
index 0000000..2246a14
--- /dev/null
+++ b/containers/pom.xml
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <packaging>pom</packaging>
+ <name>jersey-containers</name>
+
+ <description>Jersey container providers umbrella project module</description>
+
+ <modules>
+ <module>glassfish</module>
+ <module>grizzly2-http</module>
+ <module>grizzly2-servlet</module>
+ <module>jdk-http</module>
+ <module>jersey-servlet-core</module>
+ <module>jersey-servlet</module>
+ <module>jetty-http</module>
+ <module>jetty-servlet</module>
+ <module>netty-http</module>
+ <module>simple-http</module>
+ </modules>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.jersey.core</groupId>
+ <artifactId>jersey-common</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.core</groupId>
+ <artifactId>jersey-server</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>javax.ws.rs</groupId>
+ <artifactId>javax.ws.rs-api</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.inject</groupId>
+ <artifactId>jersey-hk2</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+</project>
diff --git a/containers/simple-http/pom.xml b/containers/simple-http/pom.xml
new file mode 100644
index 0000000..e3bfb38
--- /dev/null
+++ b/containers/simple-http/pom.xml
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v. 2.0, which is available at
+ http://www.eclipse.org/legal/epl-2.0.
+
+ This Source Code may also be made available under the following Secondary
+ Licenses when the conditions for such availability set forth in the
+ Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ version 2 with the GNU Classpath Exception, which is available at
+ https://www.gnu.org/software/classpath/license.html.
+
+ SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.glassfish.jersey.containers</groupId>
+ <artifactId>project</artifactId>
+ <version>2.28-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>jersey-container-simple-http</artifactId>
+ <packaging>jar</packaging>
+ <name>jersey-container-simple-http</name>
+
+ <description>Simple Http Container</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.glassfish.hk2.external</groupId>
+ <artifactId>javax.inject</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.simpleframework</groupId>
+ <artifactId>simple-http</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.simpleframework</groupId>
+ <artifactId>simple-transport</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.simpleframework</groupId>
+ <artifactId>simple-common</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>com.sun.istack</groupId>
+ <artifactId>maven-istack-commons-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <inherited>true</inherited>
+ </plugin>
+ </plugins>
+
+ <resources>
+ <resource>
+ <directory>${basedir}/src/main/java</directory>
+ <includes>
+ <include>META-INF/**/*</include>
+ </includes>
+ </resource>
+ <resource>
+ <directory>${basedir}/src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ </build>
+
+</project>
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainer.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainer.java
new file mode 100644
index 0000000..e59962f
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainer.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.Principal;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.SecurityContext;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+
+import org.glassfish.jersey.internal.MapPropertiesDelegate;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.internal.inject.ReferencingFactory;
+import org.glassfish.jersey.internal.util.ExtendedLogger;
+import org.glassfish.jersey.internal.util.collection.Ref;
+import org.glassfish.jersey.process.internal.RequestScoped;
+import org.glassfish.jersey.server.ApplicationHandler;
+import org.glassfish.jersey.server.ContainerException;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.internal.ContainerUtils;
+import org.glassfish.jersey.server.spi.Container;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+import org.glassfish.jersey.server.spi.ContainerResponseWriter.TimeoutHandler;
+
+import org.simpleframework.common.thread.DaemonFactory;
+import org.simpleframework.http.Address;
+import org.simpleframework.http.Request;
+import org.simpleframework.http.Response;
+import org.simpleframework.http.Status;
+
+/**
+ * Jersey {@code Container} implementation based on Simple framework
+ * {@link org.simpleframework.http.core.Container}.
+ *
+ * @author Arul Dhesiaseelan (aruld@acm.org)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class SimpleContainer implements org.simpleframework.http.core.Container, Container {
+
+ private static final ExtendedLogger logger =
+ new ExtendedLogger(Logger.getLogger(SimpleContainer.class.getName()), Level.FINEST);
+
+ private final Type RequestTYPE = (new GenericType<Ref<Request>>() { }).getType();
+ private final Type ResponseTYPE = (new GenericType<Ref<Response>>() { }).getType();
+
+ /**
+ * Referencing factory for Simple request.
+ */
+ private static class SimpleRequestReferencingFactory extends ReferencingFactory<Request> {
+
+ @Inject
+ public SimpleRequestReferencingFactory(final Provider<Ref<Request>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * Referencing factory for Simple response.
+ */
+ private static class SimpleResponseReferencingFactory extends ReferencingFactory<Response> {
+
+ @Inject
+ public SimpleResponseReferencingFactory(final Provider<Ref<Response>> referenceFactory) {
+ super(referenceFactory);
+ }
+ }
+
+ /**
+ * An internal binder to enable Simple HTTP container specific types injection. This binder allows
+ * to inject underlying Grizzly HTTP request and response instances.
+ */
+ private static class SimpleBinder extends AbstractBinder {
+
+ @Override
+ protected void configure() {
+ bindFactory(SimpleRequestReferencingFactory.class).to(Request.class).proxy(true)
+ .proxyForSameScope(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Request>referenceFactory())
+ .to(new GenericType<Ref<Request>>() {
+ }).in(RequestScoped.class);
+
+ bindFactory(SimpleResponseReferencingFactory.class).to(Response.class).proxy(true)
+ .proxyForSameScope(false).in(RequestScoped.class);
+ bindFactory(ReferencingFactory.<Response>referenceFactory())
+ .to(new GenericType<Ref<Response>>() {
+ }).in(RequestScoped.class);
+ }
+ }
+
+ private volatile ScheduledExecutorService scheduler;
+ private volatile ApplicationHandler appHandler;
+
+ private static final class ResponseWriter implements ContainerResponseWriter {
+
+ private final AtomicReference<TimeoutTimer> reference;
+ private final ScheduledExecutorService scheduler;
+ private final Response response;
+
+ ResponseWriter(final Response response, final ScheduledExecutorService scheduler) {
+ this.reference = new AtomicReference<TimeoutTimer>();
+ this.response = response;
+ this.scheduler = scheduler;
+ }
+
+ @Override
+ public OutputStream writeResponseStatusAndHeaders(final long contentLength,
+ final ContainerResponse context) throws ContainerException {
+ final javax.ws.rs.core.Response.StatusType statusInfo = context.getStatusInfo();
+
+ final int code = statusInfo.getStatusCode();
+ final String reason = statusInfo.getReasonPhrase() == null
+ ? Status.getDescription(code)
+ : statusInfo.getReasonPhrase();
+ response.setCode(code);
+ response.setDescription(reason);
+
+ if (contentLength != -1) {
+ response.setContentLength(contentLength);
+ }
+ for (final Map.Entry<String, List<String>> e : context.getStringHeaders().entrySet()) {
+ for (final String value : e.getValue()) {
+ response.addValue(e.getKey(), value);
+ }
+ }
+
+ try {
+ return response.getOutputStream();
+ } catch (final IOException ioe) {
+ throw new ContainerException("Error during writing out the response headers.", ioe);
+ }
+ }
+
+ @Override
+ public boolean suspend(final long timeOut, final TimeUnit timeUnit,
+ final TimeoutHandler timeoutHandler) {
+ try {
+ TimeoutTimer timer = reference.get();
+
+ if (timer == null) {
+ TimeoutDispatcher task = new TimeoutDispatcher(this, timeoutHandler);
+ ScheduledFuture<?> future =
+ scheduler.schedule(task, timeOut == 0 ? Integer.MAX_VALUE : timeOut,
+ timeOut == 0 ? TimeUnit.SECONDS : timeUnit);
+ timer = new TimeoutTimer(scheduler, future, task);
+ reference.set(timer);
+ return true;
+ }
+ return false;
+ } catch (final IllegalStateException ex) {
+ return false;
+ } finally {
+ logger.debugLog("suspend(...) called");
+ }
+ }
+
+ @Override
+ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit)
+ throws IllegalStateException {
+ try {
+ TimeoutTimer timer = reference.get();
+
+ if (timer == null) {
+ throw new IllegalStateException("Response has not been suspended");
+ }
+ timer.reschedule(timeOut, timeUnit);
+ } finally {
+ logger.debugLog("setTimeout(...) called");
+ }
+ }
+
+ @Override
+ public void commit() {
+ try {
+ response.close();
+ } catch (final IOException e) {
+ logger.log(Level.SEVERE, "Unable to send 500 error response.", e);
+ } finally {
+ logger.debugLog("commit() called");
+ }
+ }
+
+ public boolean isSuspended() {
+ return reference.get() != null;
+ }
+
+ @Override
+ public void failure(final Throwable error) {
+ try {
+ if (!response.isCommitted()) {
+ response.setCode(javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
+ response.setDescription(error.getMessage());
+ }
+ } finally {
+ logger.debugLog("failure(...) called");
+ commit();
+ rethrow(error);
+ }
+
+ }
+
+ @Override
+ public boolean enableResponseBuffering() {
+ return false;
+ }
+
+ /**
+ * Rethrow the original exception as required by JAX-RS, 3.3.4
+ *
+ * @param error throwable to be re-thrown
+ */
+ private void rethrow(final Throwable error) {
+ if (error instanceof RuntimeException) {
+ throw (RuntimeException) error;
+ } else {
+ throw new ContainerException(error);
+ }
+ }
+
+ }
+
+ private static final class TimeoutTimer {
+
+ private final AtomicReference<ScheduledFuture<?>> reference;
+ private final ScheduledExecutorService service;
+ private final TimeoutDispatcher task;
+
+ public TimeoutTimer(ScheduledExecutorService service, ScheduledFuture<?> future,
+ TimeoutDispatcher task) {
+ this.reference = new AtomicReference<ScheduledFuture<?>>();
+ this.service = service;
+ this.task = task;
+ }
+
+ public void reschedule(long timeOut, TimeUnit timeUnit) {
+ ScheduledFuture<?> future = reference.getAndSet(null);
+
+ if (future != null) {
+ if (future.cancel(false)) {
+ future = service.schedule(task, timeOut == 0 ? Integer.MAX_VALUE : timeOut,
+ timeOut == 0 ? TimeUnit.SECONDS : timeUnit);
+ reference.set(future);
+ }
+ } else {
+ future = service.schedule(task, timeOut == 0 ? Integer.MAX_VALUE : timeOut,
+ timeOut == 0 ? TimeUnit.SECONDS : timeUnit);
+ reference.set(future);
+ }
+ }
+ }
+
+ private static final class TimeoutDispatcher implements Runnable {
+
+ private final ResponseWriter writer;
+ private final TimeoutHandler handler;
+
+ public TimeoutDispatcher(ResponseWriter writer, TimeoutHandler handler) {
+ this.writer = writer;
+ this.handler = handler;
+ }
+
+ public void run() {
+ try {
+ handler.onTimeout(writer);
+ } catch (Exception e) {
+ logger.log(Level.INFO, "Failed to call timeout handler", e);
+ }
+ }
+ }
+
+ @Override
+ public void handle(final Request request, final Response response) {
+ final ResponseWriter responseWriter = new ResponseWriter(response, scheduler);
+ final URI baseUri = getBaseUri(request);
+ final URI requestUri = getRequestUri(request, baseUri);
+
+ try {
+ final ContainerRequest requestContext = new ContainerRequest(baseUri, requestUri,
+ request.getMethod(), getSecurityContext(request), new MapPropertiesDelegate());
+ requestContext.setEntityStream(request.getInputStream());
+ for (final String headerName : request.getNames()) {
+ requestContext.headers(headerName, request.getValue(headerName));
+ }
+ requestContext.setWriter(responseWriter);
+ requestContext.setRequestScopedInitializer(injectionManager -> {
+ injectionManager.<Ref<Request>>getInstance(RequestTYPE).set(request);
+ injectionManager.<Ref<Response>>getInstance(ResponseTYPE).set(response);
+ });
+
+ appHandler.handle(requestContext);
+ } catch (final Exception ex) {
+ throw new RuntimeException(ex);
+ } finally {
+ if (!responseWriter.isSuspended()) {
+ close(response);
+ }
+ }
+ }
+
+ private URI getRequestUri(final Request request, final URI baseUri) {
+ try {
+ final String serverAddress = getServerAddress(baseUri);
+ String uri = ContainerUtils.getHandlerPath(request.getTarget());
+
+ final String queryString = request.getQuery().toString();
+ if (queryString != null) {
+ uri = uri + "?" + ContainerUtils.encodeUnsafeCharacters(queryString);
+ }
+
+ return new URI(serverAddress + uri);
+ } catch (URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private String getServerAddress(final URI baseUri) throws URISyntaxException {
+ return new URI(baseUri.getScheme(), null, baseUri.getHost(), baseUri.getPort(), null, null,
+ null).toString();
+ }
+
+ private URI getBaseUri(final Request request) {
+ try {
+ final String hostHeader = request.getValue("Host");
+
+ if (hostHeader != null) {
+ final String scheme = request.isSecure() ? "https" : "http";
+ return new URI(scheme + "://" + hostHeader + "/");
+ } else {
+ final Address address = request.getAddress();
+ return new URI(address.getScheme(), null, address.getDomain(), address.getPort(), "/", null,
+ null);
+ }
+ } catch (final URISyntaxException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ private SecurityContext getSecurityContext(final Request request) {
+ return new SecurityContext() {
+
+ @Override
+ public boolean isUserInRole(final String role) {
+ return false;
+ }
+
+ @Override
+ public boolean isSecure() {
+ return request.isSecure();
+ }
+
+ @Override
+ public Principal getUserPrincipal() {
+ return null;
+ }
+
+ @Override
+ public String getAuthenticationScheme() {
+ return null;
+ }
+ };
+ }
+
+ private void close(final Response response) {
+ try {
+ response.close();
+ } catch (final Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ @Override
+ public ResourceConfig getConfiguration() {
+ return appHandler.getConfiguration();
+ }
+
+ @Override
+ public void reload() {
+ reload(getConfiguration());
+ }
+
+ @Override
+ public void reload(final ResourceConfig configuration) {
+ appHandler.onShutdown(this);
+
+ appHandler = new ApplicationHandler(configuration.register(new SimpleBinder()));
+ scheduler = new ScheduledThreadPoolExecutor(2, new DaemonFactory(TimeoutDispatcher.class));
+ appHandler.onReload(this);
+ appHandler.onStartup(this);
+ }
+
+ @Override
+ public ApplicationHandler getApplicationHandler() {
+ return appHandler;
+ }
+
+ /**
+ * Inform this container that the server has been started.
+ * <p/>
+ * This method must be implicitly called after the server containing this container is started.
+ */
+ void onServerStart() {
+ appHandler.onStartup(this);
+ }
+
+ /**
+ * Inform this container that the server is being stopped.
+ * <p/>
+ * This method must be implicitly called before the server containing this container is stopped.
+ */
+ void onServerStop() {
+ appHandler.onShutdown(this);
+ scheduler.shutdown();
+ }
+
+ /**
+ * Create a new Simple framework HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Simple framework HTTP container.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ */
+ SimpleContainer(final Application application, final Object parentContext) {
+ this.appHandler = new ApplicationHandler(application, new SimpleBinder(), parentContext);
+ this.scheduler = new ScheduledThreadPoolExecutor(2, new DaemonFactory(TimeoutDispatcher.class));
+ }
+
+ /**
+ * Create a new Simple framework HTTP container.
+ *
+ * @param application JAX-RS / Jersey application to be deployed on Simple framework HTTP
+ * container.
+ */
+ SimpleContainer(final Application application) {
+ this.appHandler = new ApplicationHandler(application, new SimpleBinder());
+ this.scheduler = new ScheduledThreadPoolExecutor(2, new DaemonFactory(TimeoutDispatcher.class));
+ }
+}
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerFactory.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerFactory.java
new file mode 100644
index 0000000..a9dc46d
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerFactory.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+
+import javax.ws.rs.ProcessingException;
+
+import javax.net.ssl.SSLContext;
+
+import org.glassfish.jersey.internal.util.collection.UnsafeValue;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.simple.internal.LocalizationMessages;
+
+import org.simpleframework.http.core.Container;
+import org.simpleframework.http.core.ContainerSocketProcessor;
+import org.simpleframework.transport.SocketProcessor;
+import org.simpleframework.transport.connect.Connection;
+import org.simpleframework.transport.connect.SocketConnection;
+
+/**
+ * Factory for creating and starting Simple server containers. This returns a handle to the started
+ * server as {@link Closeable} instances, which allows the server to be stopped by invoking the
+ * {@link Closeable#close} method.
+ * <p/>
+ * To start the server in HTTPS mode an {@link SSLContext} can be provided. This will be used to
+ * decrypt and encrypt information sent over the connected TCP socket channel.
+ *
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ * @author Paul Sandoz
+ */
+public final class SimpleContainerFactory {
+
+ private SimpleContainerFactory() {
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes declared by the resource configuration.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to "http". The
+ * URI user information and host are ignored If the URI port is not present then port 80
+ * will be used. The URI path, query and fragment components are ignored.
+ * @param config the resource configuration.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final ResourceConfig config) {
+ return create(address, null, new SimpleContainer(config));
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes declared by the resource configuration.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to "http". The
+ * URI user information and host are ignored If the URI port is not present then port 80
+ * will be used. The URI path, query and fragment components are ignored.
+ * @param config the resource configuration.
+ * @param count this is the number of threads to be used.
+ * @param select this is the number of selector threads to use.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final ResourceConfig config, final int count,
+ final int select) {
+ return create(address, null, new SimpleContainer(config), count, select);
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes declared by the resource configuration.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to {@code https}
+ * . The URI user information and host are ignored. If the URI port is not present then
+ * port {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be used.
+ * The URI path, query and fragment components are ignored.
+ * @param context this is the SSL context used for SSL connections.
+ * @param config the resource configuration.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final SSLContext context,
+ final ResourceConfig config) {
+ return create(address, context, new SimpleContainer(config));
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes declared by the resource configuration.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to {@code https}
+ * . The URI user information and host are ignored. If the URI port is not present then
+ * port {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be used.
+ * The URI path, query and fragment components are ignored.
+ * @param context this is the SSL context used for SSL connections.
+ * @param config the resource configuration.
+ * @param count this is the number of threads to be used.
+ * @param select this is the number of selector threads to use.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final SSLContext context,
+ final ResourceConfig config, final int count, final int select) {
+ return create(address, context, new SimpleContainer(config), count, select);
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes found by searching the classes referenced in the java classpath.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to {@code https}
+ * . The URI user information and host are ignored. If the URI port is not present then
+ * port {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be used.
+ * The URI path, query and fragment components are ignored.
+ * @param context this is the SSL context used for SSL connections.
+ * @param container the container that handles all HTTP requests.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final SSLContext context,
+ final SimpleContainer container) {
+ return _create(address, context, container, new UnsafeValue<SocketProcessor, IOException>() {
+ @Override
+ public SocketProcessor get() throws IOException {
+ return new ContainerSocketProcessor(container);
+ }
+ });
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes declared by the resource configuration.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to {@code https}
+ * . The URI user information and host are ignored. If the URI port is not present then
+ * port {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be used.
+ * The URI path, query and fragment components are ignored.
+ * @param context this is the SSL context used for SSL connections.
+ * @param config the resource configuration.
+ * @param parentContext DI provider specific context with application's registered bindings.
+ * @param count this is the number of threads to be used.
+ * @param select this is the number of selector threads to use.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ * @since 2.12
+ */
+ public static SimpleServer create(final URI address, final SSLContext context,
+ final ResourceConfig config, final Object parentContext, final int count,
+ final int select) {
+ return create(address, context, new SimpleContainer(config, parentContext), count, select);
+ }
+
+ /**
+ * Create a {@link Closeable} that registers an {@link Container} that in turn manages all root
+ * resource and provider classes found by searching the classes referenced in the java classpath.
+ *
+ * @param address the URI to create the http server. The URI scheme must be equal to {@code https}
+ * . The URI user information and host are ignored. If the URI port is not present then
+ * port {@value org.glassfish.jersey.server.spi.Container#DEFAULT_HTTPS_PORT} will be used.
+ * The URI path, query and fragment components are ignored.
+ * @param context this is the SSL context used for SSL connections.
+ * @param container the container that handles all HTTP requests.
+ * @param count this is the number of threads to be used.
+ * @param select this is the number of selector threads to use.
+ * @return the closeable connection, with the endpoint started.
+ * @throws ProcessingException thrown when problems during server creation.
+ * @throws IllegalArgumentException if {@code address} is {@code null}.
+ */
+ public static SimpleServer create(final URI address, final SSLContext context,
+ final SimpleContainer container, final int count, final int select)
+ throws ProcessingException {
+
+ return _create(address, context, container, new UnsafeValue<SocketProcessor, IOException>() {
+ @Override
+ public SocketProcessor get() throws IOException {
+ return new ContainerSocketProcessor(container, count, select);
+ }
+ });
+ }
+
+ private static SimpleServer _create(final URI address, final SSLContext context,
+ final SimpleContainer container,
+ final UnsafeValue<SocketProcessor, IOException> serverProvider)
+ throws ProcessingException {
+ if (address == null) {
+ throw new IllegalArgumentException(LocalizationMessages.URI_CANNOT_BE_NULL());
+ }
+ final String scheme = address.getScheme();
+ int defaultPort = org.glassfish.jersey.server.spi.Container.DEFAULT_HTTP_PORT;
+
+ if (context == null) {
+ if (!scheme.equalsIgnoreCase("http")) {
+ throw new IllegalArgumentException(LocalizationMessages.WRONG_SCHEME_WHEN_USING_HTTP());
+ }
+ } else {
+ if (!scheme.equalsIgnoreCase("https")) {
+ throw new IllegalArgumentException(LocalizationMessages.WRONG_SCHEME_WHEN_USING_HTTPS());
+ }
+ defaultPort = org.glassfish.jersey.server.spi.Container.DEFAULT_HTTPS_PORT;
+ }
+ int port = address.getPort();
+
+ if (port == -1) {
+ port = defaultPort;
+ }
+ final InetSocketAddress listen = new InetSocketAddress(port);
+ final Connection connection;
+ try {
+ final SimpleTraceAnalyzer analyzer = new SimpleTraceAnalyzer();
+ final SocketProcessor server = serverProvider.get();
+ connection = new SocketConnection(server, analyzer);
+
+
+ final SocketAddress socketAddr = connection.connect(listen, context);
+ container.onServerStart();
+
+ return new SimpleServer() {
+
+ @Override
+ public void close() throws IOException {
+ container.onServerStop();
+ analyzer.stop();
+ connection.close();
+ }
+
+ @Override
+ public int getPort() {
+ return ((InetSocketAddress) socketAddr).getPort();
+ }
+
+ @Override
+ public boolean isDebug() {
+ return analyzer.isActive();
+ }
+
+ @Override
+ public void setDebug(boolean enable) {
+ if (enable) {
+ analyzer.start();
+ } else {
+ analyzer.stop();
+ }
+ }
+ };
+ } catch (final IOException ex) {
+ throw new ProcessingException(LocalizationMessages.ERROR_WHEN_CREATING_SERVER(), ex);
+ }
+ }
+}
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerProvider.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerProvider.java
new file mode 100644
index 0000000..68f8f0f
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleContainerProvider.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.core.Application;
+
+import org.glassfish.jersey.server.spi.ContainerProvider;
+
+import org.simpleframework.http.core.Container;
+
+/**
+ * Container provider for containers based on Simple HTTP Server
+ * {@link org.simpleframework.http.core.Container}.
+ *
+ * @author Marc Hadley
+ * @author Arul Dhesiaseelan (aruld@acm.org)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public final class SimpleContainerProvider implements ContainerProvider {
+
+ @Override
+ public <T> T createContainer(Class<T> type, Application application) throws ProcessingException {
+ if (Container.class == type || SimpleContainer.class == type) {
+ return type.cast(new SimpleContainer(application));
+ }
+ return null;
+ }
+
+}
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleServer.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleServer.java
new file mode 100644
index 0000000..02aec75
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleServer.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.io.Closeable;
+
+/**
+ * Simple server facade providing convenient methods to obtain info about the server (i.e. port).
+ *
+ * @author Michal Gajdos
+ * @since 2.9
+ */
+public interface SimpleServer extends Closeable {
+
+ /**
+ * The port the server is listening to for incomming HTTP connections. If the port is not
+ * specified the {@link org.glassfish.jersey.server.spi.Container.DEFAULT_PORT} is used.
+ *
+ * @return the port the server is listening on
+ */
+ public int getPort();
+
+ /**
+ * If this is true then very low level I/O operations are logged. Typically this is used to debug
+ * I/O issues such as HTTPS handshakes or performance issues by analysing the various latencies
+ * involved in the HTTP conversation.
+ * <p/>
+ * There is a minimal performance penalty if this is enabled and it is perfectly suited to being
+ * enabled in a production environment, at the cost of logging overhead.
+ *
+ * @return {@code true} if debug is enabled, false otherwise.
+ * @since 2.23
+ */
+ public boolean isDebug();
+
+ /**
+ * To enable very low level logging this can be enabled. This goes far beyond logging issues such
+ * as connection establishment of request dispatch, it can trace the TCP operations latencies
+ * involved.
+ *
+ * @param enable if {@code true} debug tracing will be enabled.
+ * @since 2.23
+ */
+ public void setDebug(boolean enable);
+}
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleTraceAnalyzer.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleTraceAnalyzer.java
new file mode 100644
index 0000000..4873da1
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/SimpleTraceAnalyzer.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.channels.SelectableChannel;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.glassfish.jersey.internal.util.ExtendedLogger;
+
+import org.simpleframework.common.thread.DaemonFactory;
+import org.simpleframework.transport.trace.Trace;
+import org.simpleframework.transport.trace.TraceAnalyzer;
+
+/**
+ * Tracing at a very low level can be performed with a {@link TraceAnalyzer}. This provides much
+ * more useful information than the conventional {@link LoggingFilter} in that it provides details
+ * at a very low level. This is very useful when monitoring performance interactions at the TCP
+ * level between clients and servers.
+ * <p/>
+ * Performance overhead for the server is minimal as events are pumped out in batches. The amount of
+ * logging information will increase quite significantly though.
+ *
+ * @author Niall Gallagher
+ */
+public class SimpleTraceAnalyzer implements TraceAnalyzer {
+
+ private static final ExtendedLogger logger =
+ new ExtendedLogger(Logger.getLogger(SimpleTraceAnalyzer.class.getName()), Level.FINEST);
+
+ private final TraceConsumer consumer;
+ private final ThreadFactory factory;
+ private final AtomicBoolean active;
+ private final AtomicLong count;
+
+ /**
+ * Creates an asynchronous trace event logger.
+ */
+ public SimpleTraceAnalyzer() {
+ this.factory = new DaemonFactory(TraceConsumer.class);
+ this.consumer = new TraceConsumer();
+ this.active = new AtomicBoolean();
+ this.count = new AtomicLong();
+ }
+
+ public boolean isActive() {
+ return active.get();
+ }
+
+ @Override
+ public Trace attach(SelectableChannel channel) {
+ long sequence = count.getAndIncrement();
+ return new TraceFeeder(channel, sequence);
+ }
+
+ /**
+ * Begin logging trace events to the underlying logger.
+ */
+ public void start() {
+ if (active.compareAndSet(false, true)) {
+ Thread thread = factory.newThread(consumer);
+ thread.start();
+ }
+ }
+
+ @Override
+ public void stop() {
+ active.set(false);
+ }
+
+ private class TraceConsumer implements Runnable {
+
+ private final Queue<TraceRecord> queue;
+
+ public TraceConsumer() {
+ this.queue = new ConcurrentLinkedQueue<TraceRecord>();
+ }
+
+ public void consume(TraceRecord record) {
+ queue.offer(record);
+ }
+
+ public void run() {
+ try {
+ while (active.get()) {
+ Thread.sleep(1000);
+ drain();
+ }
+ } catch (Exception e) {
+ logger.info("Trace analyzer error");
+ } finally {
+ try {
+ drain();
+ } catch (Exception e) {
+ logger.info("Trace analyzer could not drain queue");
+ }
+ active.set(false);
+ }
+
+ }
+
+ private void drain() {
+ while (!queue.isEmpty()) {
+ TraceRecord record = queue.poll();
+
+ if (record != null) {
+ String message = record.toString();
+ logger.info(message);
+ }
+ }
+ }
+ }
+
+ private class TraceFeeder implements Trace {
+
+ private final SelectableChannel channel;
+ private final long sequence;
+
+ public TraceFeeder(SelectableChannel channel, long sequence) {
+ this.sequence = sequence;
+ this.channel = channel;
+ }
+
+ @Override
+ public void trace(Object event) {
+ trace(event, null);
+ }
+
+ @Override
+ public void trace(Object event, Object value) {
+ if (active.get()) {
+ TraceRecord record = new TraceRecord(channel, event, value, sequence);
+ consumer.consume(record);
+ }
+ }
+
+ }
+
+ private class TraceRecord {
+
+ private final SelectableChannel channel;
+ private final String thread;
+ private final Object event;
+ private final Object value;
+ private final long sequence;
+
+ public TraceRecord(SelectableChannel channel, Object event, Object value, long sequence) {
+ this.thread = Thread.currentThread().getName();
+ this.sequence = sequence;
+ this.channel = channel;
+ this.event = event;
+ this.value = value;
+ }
+
+ public String toString() {
+ StringWriter builder = new StringWriter();
+ PrintWriter writer = new PrintWriter(builder);
+
+ writer.print(sequence);
+ writer.print(" ");
+ writer.print(channel);
+ writer.print(" (");
+ writer.print(thread);
+ writer.print("): ");
+ writer.print(event);
+
+ if (value != null) {
+ if (value instanceof Throwable) {
+ writer.print(" -> ");
+ ((Throwable) value).printStackTrace(writer);
+ } else {
+ writer.print(" -> ");
+ writer.print(value);
+ }
+ }
+ writer.close();
+ return builder.toString();
+ }
+ }
+}
diff --git a/containers/simple-http/src/main/java/org/glassfish/jersey/simple/package-info.java b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/package-info.java
new file mode 100644
index 0000000..f7a4d38
--- /dev/null
+++ b/containers/simple-http/src/main/java/org/glassfish/jersey/simple/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey Simple 6.x container classes.
+ */
+package org.glassfish.jersey.simple;
diff --git a/containers/simple-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider b/containers/simple-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
new file mode 100644
index 0000000..a0a4981
--- /dev/null
+++ b/containers/simple-http/src/main/resources/META-INF/services/org.glassfish.jersey.server.spi.ContainerProvider
@@ -0,0 +1 @@
+org.glassfish.jersey.simple.SimpleContainerProvider
\ No newline at end of file
diff --git a/containers/simple-http/src/main/resources/org.glassfish.jersey.simple.internal/localization.properties b/containers/simple-http/src/main/resources/org.glassfish.jersey.simple.internal/localization.properties
new file mode 100644
index 0000000..138fa5b
--- /dev/null
+++ b/containers/simple-http/src/main/resources/org.glassfish.jersey.simple.internal/localization.properties
@@ -0,0 +1,20 @@
+#
+# Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+error.when.creating.server=IOException thrown when trying to create simple server.
+uri.cannot.be.null=The URI must not be null.
+wrong.scheme.when.using.http=The URI scheme should be 'http' when not using SSL.
+wrong.scheme.when.using.https=The URI scheme should be 'https' when using SSL.
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AbstractSimpleServerTester.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AbstractSimpleServerTester.java
new file mode 100644
index 0000000..eb653ca
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AbstractSimpleServerTester.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.net.URI;
+import java.security.AccessController;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.internal.util.PropertiesHelper;
+import org.glassfish.jersey.logging.LoggingFeature;
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.junit.After;
+
+/**
+ * Abstract Simple HTTP Server unit tester.
+ *
+ * @author Paul Sandoz
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ * @author Miroslav Fuksa
+ */
+public abstract class AbstractSimpleServerTester {
+
+ public static final String CONTEXT = "";
+ private final int DEFAULT_PORT = 9998;
+
+ private static final Logger LOGGER = Logger.getLogger(AbstractSimpleServerTester.class.getName());
+
+ /**
+ * Get the port to be used for test application deployments.
+ *
+ * @return The HTTP port of the URI
+ */
+ protected final int getPort() {
+ final String value = AccessController
+ .doPrivileged(PropertiesHelper.getSystemProperty("jersey.config.test.container.port"));
+ if (value != null) {
+
+ try {
+ final int i = Integer.parseInt(value);
+ if (i <= 0) {
+ throw new NumberFormatException("Value not positive.");
+ }
+ return i;
+ } catch (NumberFormatException e) {
+ LOGGER.log(
+ Level.CONFIG,
+ "Value of 'jersey.config.test.container.port'"
+ + " property is not a valid positive integer [" + value + "]."
+ + " Reverting to default [" + DEFAULT_PORT + "].",
+ e);
+ }
+ }
+
+ return DEFAULT_PORT;
+ }
+
+ private volatile SimpleServer server;
+
+ public UriBuilder getUri() {
+ return UriBuilder.fromUri("http://localhost").port(getPort()).path(CONTEXT);
+ }
+
+ public void startServer(Class... resources) {
+ ResourceConfig config = new ResourceConfig(resources);
+ config.register(LoggingFeature.class);
+ final URI baseUri = getBaseUri();
+ server = SimpleContainerFactory.create(baseUri, config);
+ LOGGER.log(Level.INFO, "Simple-http server started on base uri: " + baseUri);
+ }
+
+ public void startServerNoLoggingFilter(Class... resources) {
+ ResourceConfig config = new ResourceConfig(resources);
+ final URI baseUri = getBaseUri();
+ server = SimpleContainerFactory.create(baseUri, config);
+ LOGGER.log(Level.INFO, "Simple-http server started on base uri: " + baseUri);
+ }
+
+ public void startServer(ResourceConfig config) {
+ final URI baseUri = getBaseUri();
+ config.register(LoggingFeature.class);
+ server = SimpleContainerFactory.create(baseUri, config);
+ LOGGER.log(Level.INFO, "Simple-http server started on base uri: " + baseUri);
+ }
+
+ public void startServer(ResourceConfig config, int count, int select) {
+ final URI baseUri = getBaseUri();
+ config.register(LoggingFeature.class);
+ server = SimpleContainerFactory.create(baseUri, config, count, select);
+ LOGGER.log(Level.INFO, "Simple-http server started on base uri: " + baseUri);
+ }
+
+ public URI getBaseUri() {
+ return UriBuilder.fromUri("http://localhost/").port(getPort()).build();
+ }
+
+ public void setDebug(boolean enable) {
+ if (server != null) {
+ server.setDebug(enable);
+ }
+ }
+
+ public void stopServer() {
+ try {
+ server.close();
+ server = null;
+ LOGGER.log(Level.INFO, "Simple-http server stopped.");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @After
+ public void tearDown() {
+ if (server != null) {
+ stopServer();
+ }
+ }
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AsyncTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AsyncTest.java
new file mode 100644
index 0000000..9587b04
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/AsyncTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.container.AsyncResponse;
+import javax.ws.rs.container.Suspended;
+import javax.ws.rs.container.TimeoutHandler;
+import javax.ws.rs.core.Response;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+/**
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ * @author Michal Gajdos
+ */
+public class AsyncTest extends AbstractSimpleServerTester {
+
+ @Path("/async")
+ @SuppressWarnings("VoidMethodAnnotatedWithGET")
+ public static class AsyncResource {
+
+ public static AtomicInteger INVOCATION_COUNT = new AtomicInteger(0);
+
+ @GET
+ public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
+ new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ final String result = veryExpensiveOperation();
+ asyncResponse.resume(result);
+ }
+
+ private String veryExpensiveOperation() {
+ // ... very expensive operation that typically finishes within 5 seconds, simulated using
+ // sleep()
+ try {
+ Thread.sleep(5000);
+ } catch (final InterruptedException e) {
+ // ignore
+ }
+ return "DONE";
+ }
+ }).start();
+ }
+
+ @GET
+ @Path("timeout")
+ public void asyncGetWithTimeout(@Suspended final AsyncResponse asyncResponse) {
+ asyncResponse.setTimeoutHandler(new TimeoutHandler() {
+
+ @Override
+ public void handleTimeout(final AsyncResponse asyncResponse) {
+ asyncResponse.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE)
+ .entity("Operation time out.").build());
+ }
+ });
+ asyncResponse.setTimeout(3, TimeUnit.SECONDS);
+
+ new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ final String result = veryExpensiveOperation();
+ asyncResponse.resume(result);
+ }
+
+ private String veryExpensiveOperation() {
+ // ... very expensive operation that typically finishes within 10 seconds, simulated using
+ // sleep()
+ try {
+ Thread.sleep(7000);
+ } catch (final InterruptedException e) {
+ // ignore
+ }
+ return "DONE";
+ }
+ }).start();
+ }
+
+ @GET
+ @Path("multiple-invocations")
+ public void asyncMultipleInvocations(@Suspended final AsyncResponse asyncResponse) {
+ INVOCATION_COUNT.incrementAndGet();
+
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ asyncResponse.resume("OK");
+ }
+ }).start();
+ }
+ }
+
+ private Client client;
+
+ @Before
+ public void setUp() throws Exception {
+ startServer(AsyncResource.class);
+ client = ClientBuilder.newClient();
+ }
+
+ @Override
+ @After
+ public void tearDown() {
+ super.tearDown();
+ client = null;
+ }
+
+ @Test
+ public void testAsyncGet() throws ExecutionException, InterruptedException {
+ final Future<Response> responseFuture =
+ client.target(getUri().path("/async")).request().async().get();
+ // Request is being processed asynchronously.
+ final Response response = responseFuture.get();
+ // get() waits for the response
+ assertEquals("DONE", response.readEntity(String.class));
+ }
+
+ @Test
+ public void testAsyncGetWithTimeout()
+ throws ExecutionException, InterruptedException, TimeoutException {
+ final Future<Response> responseFuture =
+ client.target(getUri().path("/async/timeout")).request().async().get();
+ // Request is being processed asynchronously.
+ final Response response = responseFuture.get();
+
+ // get() waits for the response
+ assertEquals(503, response.getStatus());
+ assertEquals("Operation time out.", response.readEntity(String.class));
+ }
+
+ /**
+ * JERSEY-2616 reproducer. Make sure resource method is only invoked once per one request.
+ */
+ @Test
+ public void testAsyncMultipleInvocations() throws Exception {
+ final Response response =
+ client.target(getUri().path("/async/multiple-invocations")).request().get();
+
+ assertThat(AsyncResource.INVOCATION_COUNT.get(), is(1));
+
+ assertThat(response.getStatus(), is(200));
+ assertThat(response.readEntity(String.class), is("OK"));
+ }
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ExceptionTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ExceptionTest.java
new file mode 100644
index 0000000..15e7b28
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ExceptionTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Paul Sandoz
+ */
+public class ExceptionTest extends AbstractSimpleServerTester {
+ @Path("{status}")
+ public static class ExceptionResource {
+ @GET
+ public String get(@PathParam("status") int status) {
+ throw new WebApplicationException(status);
+ }
+
+ }
+
+ @Test
+ public void test400StatusCode() {
+ startServer(ExceptionResource.class);
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("400").build());
+ assertEquals(400, r.request().get(Response.class).getStatus());
+ }
+
+ @Test
+ public void test500StatusCode() {
+ startServer(ExceptionResource.class);
+ Client client = ClientBuilder.newClient();
+ WebTarget r = client.target(getUri().path("500").build());
+
+ assertEquals(500, r.request().get(Response.class).getStatus());
+ }
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/LifecycleListenerTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/LifecycleListenerTest.java
new file mode 100644
index 0000000..439b7d2
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/LifecycleListenerTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.server.spi.AbstractContainerLifecycleListener;
+import org.glassfish.jersey.server.spi.Container;
+
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+
+/**
+ * Reload and ContainerLifecycleListener support test.
+ *
+ * @author Paul Sandoz
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class LifecycleListenerTest extends AbstractSimpleServerTester {
+
+ @Path("/one")
+ public static class One {
+ @GET
+ public String get() {
+ return "one";
+ }
+ }
+
+ @Path("/two")
+ public static class Two {
+ @GET
+ public String get() {
+ return "two";
+ }
+ }
+
+ public static class Reloader extends AbstractContainerLifecycleListener {
+ Container container;
+
+ public void reload(ResourceConfig newConfig) {
+ container.reload(newConfig);
+ }
+
+ public void reload() {
+ container.reload();
+ }
+
+ @Override
+ public void onStartup(Container container) {
+ this.container = container;
+ }
+
+ }
+
+ @Test
+ public void testReload() {
+ final ResourceConfig rc = new ResourceConfig(One.class);
+
+ Reloader reloader = new Reloader();
+ rc.registerInstances(reloader);
+
+ startServer(rc);
+
+ WebTarget r = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals(404, r.path("two").request().get(Response.class).getStatus());
+
+ // add Two resource
+ reloader.reload(new ResourceConfig(One.class, Two.class));
+
+ assertEquals("one", r.path("one").request().get(String.class));
+ assertEquals("two", r.path("two").request().get(String.class));
+ }
+
+ static class StartStopListener extends AbstractContainerLifecycleListener {
+ volatile boolean started;
+ volatile boolean stopped;
+
+ @Override
+ public void onStartup(Container container) {
+ started = true;
+ }
+
+ @Override
+ public void onShutdown(Container container) {
+ stopped = true;
+ }
+ }
+
+ @Test
+ public void testStartupShutdownHooks() {
+ final StartStopListener listener = new StartStopListener();
+
+ startServer(new ResourceConfig(One.class).register(listener));
+
+ WebTarget r = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ assertThat(r.path("one").request().get(String.class), equalTo("one"));
+ assertThat(r.path("two").request().get(Response.class).getStatus(), equalTo(404));
+
+ stopServer();
+
+ assertTrue("ContainerLifecycleListener.onStartup has not been called.", listener.started);
+ assertTrue("ContainerLifecycleListener.onShutdown has not been called.", listener.stopped);
+ }
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/OptionsTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/OptionsTest.java
new file mode 100644
index 0000000..3b12b1a
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/OptionsTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.Response;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class OptionsTest extends AbstractSimpleServerTester {
+
+ @Path("helloworld")
+ public static class HelloWorldResource {
+ public static final String CLICHED_MESSAGE = "Hello World!";
+
+ @GET
+ @Produces("text/plain")
+ public String getHello() {
+ return CLICHED_MESSAGE;
+ }
+ }
+
+ @Path("/users")
+ public class UserResource {
+
+ @Path("/current")
+ @GET
+ @Produces("text/plain")
+ public String getCurrentUser() {
+ return "current user";
+ }
+ }
+
+ private Client client;
+
+ @Before
+ public void setUp() throws Exception {
+ startServer(HelloWorldResource.class, UserResource.class);
+ client = ClientBuilder.newClient();
+ }
+
+ @Override
+ @After
+ public void tearDown() {
+ super.tearDown();
+ client = null;
+ }
+
+
+ @Test
+ public void testFooBarOptions() {
+ Response response =
+ client.target(getUri()).path("helloworld").request().header("Accept", "foo/bar").options();
+ assertEquals(200, response.getStatus());
+ final String allowHeader = response.getHeaderString("Allow");
+ _checkAllowContent(allowHeader);
+ assertEquals(0, response.getLength());
+ assertEquals("foo/bar", response.getMediaType().toString());
+ }
+
+ private void _checkAllowContent(final String content) {
+ assertTrue(content.contains("GET"));
+ assertTrue(content.contains("HEAD"));
+ assertTrue(content.contains("OPTIONS"));
+ }
+
+ @Test
+ public void testNoDefaultMethod() {
+ Response response = client.target(getUri()).path("/users").request().options();
+ assertThat(response.getStatus(), is(404));
+ }
+
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ParallelTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ParallelTest.java
new file mode 100644
index 0000000..e0b6611
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/ParallelTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+
+import org.glassfish.jersey.server.ResourceConfig;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests the parallel execution of multiple requests.
+ *
+ * @author Stepan Kopriva
+ * @author Arul Dhesiaseelan (aruld at acm.org)
+ */
+public class ParallelTest extends AbstractSimpleServerTester {
+
+ // Server-side dispatcher and selector pool configuration
+ private static final int selectorThreads = Runtime.getRuntime().availableProcessors();
+ private static final int dispatcherThreads = Math.max(8, selectorThreads * 2);
+
+ private static final int numberOfThreads = 100;
+
+ private static final String PATH = "test";
+ private static AtomicInteger receivedCounter = new AtomicInteger(0);
+ private static AtomicInteger resourceCounter = new AtomicInteger(0);
+ private static CountDownLatch latch = new CountDownLatch(numberOfThreads);
+
+ @Path(PATH)
+ public static class MyResource {
+
+ @GET
+ public String get() {
+ this.sleep();
+ resourceCounter.addAndGet(1);
+ return "GET";
+ }
+
+ private void sleep() {
+ try {
+ Thread.sleep(10);
+ } catch (InterruptedException ex) {
+ Logger.getLogger(ParallelTest.class.getName()).log(Level.SEVERE, null, ex);
+ }
+ }
+ }
+
+ private class ResourceThread extends Thread {
+
+ private WebTarget target;
+ private String path;
+
+ public ResourceThread(WebTarget target, String path) {
+ this.target = target;
+ this.path = path;
+ }
+
+ @Override
+ public void run() {
+ assertEquals("GET", target.path(path).request().get(String.class));
+ receivedCounter.addAndGet(1);
+ latch.countDown();
+ }
+ }
+
+ @Test
+ public void testParallel() {
+ ResourceConfig config = new ResourceConfig(MyResource.class);
+ startServer(config, dispatcherThreads, selectorThreads);
+ WebTarget target = ClientBuilder.newClient().target(getUri().path("/").build());
+
+ for (int i = 1; i <= numberOfThreads; i++) {
+ ResourceThread rt = new ResourceThread(target, PATH);
+ rt.start();
+ }
+
+ try {
+ latch.await(8000, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException ex) {
+ Logger.getLogger(ParallelTest.class.getName()).log(Level.SEVERE, null, ex);
+ }
+
+ int result = receivedCounter.get();
+ assertEquals(numberOfThreads, result);
+ }
+}
diff --git a/containers/simple-http/src/test/java/org/glassfish/jersey/simple/TraceTest.java b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/TraceTest.java
new file mode 100644
index 0000000..1e2d737
--- /dev/null
+++ b/containers/simple-http/src/test/java/org/glassfish/jersey/simple/TraceTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.simple;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.Response;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TraceTest extends AbstractSimpleServerTester {
+
+ @Path("helloworld")
+ public static class HelloWorldResource {
+ public static final String CLICHED_MESSAGE = "Hello World!";
+
+ @GET
+ @Produces("text/plain")
+ public String getHello() {
+ return CLICHED_MESSAGE;
+ }
+ }
+
+ @Path("/users")
+ public class UserResource {
+
+ @Path("/current")
+ @GET
+ @Produces("text/plain")
+ public String getCurrentUser() {
+ return "current user";
+ }
+ }
+
+ private Client client;
+
+ @Before
+ public void setUp() throws Exception {
+ startServerNoLoggingFilter(HelloWorldResource.class, UserResource.class); // disable crude
+ // LoggingFilter
+ setDebug(true);
+ client = ClientBuilder.newClient();
+ }
+
+ @Override
+ @After
+ public void tearDown() {
+ super.tearDown();
+ client = null;
+ }
+
+
+ @Test
+ public void testFooBarOptions() {
+ for (int i = 0; i < 100; i++) {
+ Response response = client.target(getUri()).path("helloworld").request()
+ .header("Accept", "foo/bar").options();
+ assertEquals(200, response.getStatus());
+ final String allowHeader = response.getHeaderString("Allow");
+ _checkAllowContent(allowHeader);
+ assertEquals(0, response.getLength());
+ assertEquals("foo/bar", response.getMediaType().toString());
+
+ try {
+ Thread.sleep(50);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ private void _checkAllowContent(final String content) {
+ assertTrue(content.contains("GET"));
+ assertTrue(content.contains("HEAD"));
+ assertTrue(content.contains("OPTIONS"));
+ }
+
+ @Test
+ public void testNoDefaultMethod() {
+ Response response = client.target(getUri()).path("/users").request().options();
+ assertThat(response.getStatus(), is(404));
+ }
+}
