#3993

Committed 19 Jan 2025 05:13AM CUT coverage: 35.394% (+0.04%) from 35.353%

Build # #3993

Build Type

push

github

Committed by

topframe

Commit Message

Update

Run Details

21 of 24 new or added lines in 2 files covered. (87.5%)

4 existing lines in 1 file now uncovered.

14227 of 40196 relevant lines covered (35.39%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.02

/with-jetty/src/main/java/com/aspectran/jetty/server/servlet/JettyWebAppContext.java

/*
 * Copyright (c) 2008-2025 The Aspectran Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.aspectran.jetty.server.servlet;

import com.aspectran.core.component.bean.annotation.AvoidAdvice;
import com.aspectran.core.component.bean.aware.ActivityContextAware;
import com.aspectran.core.context.ActivityContext;
import com.aspectran.core.service.CoreService;
import com.aspectran.utils.Assert;
import com.aspectran.utils.StringUtils;
import com.aspectran.utils.annotation.jsr305.NonNull;
import com.aspectran.utils.logging.Logger;
import com.aspectran.utils.logging.LoggerFactory;
import com.aspectran.web.service.DefaultWebService;
import com.aspectran.web.service.DefaultWebServiceBuilder;
import com.aspectran.web.service.WebService;
import jakarta.servlet.ServletContainerInitializer;
import jakarta.websocket.server.ServerContainer;
import org.eclipse.jetty.ee10.servlet.ErrorPageErrorHandler;
import org.eclipse.jetty.ee10.servlet.ServletMapping;
import org.eclipse.jetty.ee10.webapp.WebAppClassLoader;
import org.eclipse.jetty.ee10.webapp.WebAppContext;
import org.eclipse.jetty.ee10.webapp.WebXmlConfiguration;
import org.eclipse.jetty.ee10.websocket.jakarta.server.JakartaWebSocketServerContainer;
import org.eclipse.jetty.ee10.websocket.jakarta.server.config.JakartaWebSocketServletContainerInitializer;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.util.component.LifeCycle;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.util.resource.Resources;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.Arrays;
import java.util.EventListener;
import java.util.List;
import java.util.Map;

/**
 * The Class JettyWebAppContext.
 *
 * <p>Created: 2017. 1. 27.</p>
 */
public class JettyWebAppContext extends WebAppContext implements ActivityContextAware {

    private static final Logger logger = LoggerFactory.getLogger(JettyWebAppContext.class);

    private ActivityContext context;

    private List<JettyErrorPage> errorPages;

    private JettyWebSocketInitializer webSocketInitializer;

    @NonNull
    private ActivityContext getActivityContext() {
        Assert.state(context != null, "No ActivityContext injected");
        return context;
    }

    @Override
    @AvoidAdvice
    public void setActivityContext(@NonNull ActivityContext context) {
        this.context = context;
    }

    @Override
    public void setWar(String war) {
        try {
            File warFile = new File(war);
            if (warFile.isDirectory()) {
                if (!warFile.exists() && !warFile.mkdirs()) {
                    throw new IOException("Unable to create WAR directory: " + warFile);
                }
            }
            super.setWar(warFile.getCanonicalPath());
        } catch (Exception e) {
            logger.error("Failed to establish WAR of the webapp: " + war, e);
        }
    }

    public void setTempDirectory(String tempDirectory) {
        try {
            File tempDir = new File(tempDirectory);
            if (!tempDir.exists()) {
                if (!tempDir.mkdirs()) {
                    throw new IOException("Unable to create scratch directory: " + tempDir);
                }
            }
            super.setTempDirectory(tempDir.getCanonicalFile());
        } catch (Exception e) {
            logger.error("Failed to establish scratch directory: " + tempDirectory, e);
        }
    }

    @Override
    public void setDefaultsDescriptor(String defaultsDescriptor) {
        if (StringUtils.hasLength(defaultsDescriptor)) {
            Resource dftResource;
            try {
                dftResource = getResourceFactory().newClassLoaderResource(defaultsDescriptor);
                if (Resources.missing(dftResource)) {
                    String pkg = WebXmlConfiguration.class.getPackageName().replace(".", "/") + "/";
                    if (defaultsDescriptor.startsWith(pkg)) {
                        URL url = WebXmlConfiguration.class.getResource(defaultsDescriptor.substring(pkg.length()));
                        if (url != null) {
                            URI uri = url.toURI();
                            dftResource = getResourceFactory().newResource(uri);
                        }
                    }
                    if (Resources.missing(dftResource)) {
                        dftResource = newResource(defaultsDescriptor);
                    }
                }
            } catch (Exception e) {
                throw new IllegalArgumentException("Invalid default descriptor: " + defaultsDescriptor, e);
            }
            if (Resources.isReadableFile(dftResource)) {
                super.setDefaultsDescriptor(defaultsDescriptor);
            } else {
                throw new IllegalArgumentException("Unable to locate default descriptor: " + defaultsDescriptor);
            }
        }
    }

    public void setInitParams(Map<String, String> initParams) {
        if (initParams != null) {
            for (Map.Entry<String, String> entry : initParams.entrySet()) {
                setInitParameter(entry.getKey(), entry.getValue());
            }
        }
    }

    public void setListeners(JettyListener[] jettyListeners) {
        if (jettyListeners != null) {
            for (JettyListener jettyListener : jettyListeners) {
                getServletHandler().addListener(jettyListener);
            }
        }
    }

    /**
     * Any event listeners added as WebListener must implement one or more of the
     * {@link jakarta.servlet.ServletContextListener}, {@link jakarta.servlet.ServletContextAttributeListener},
     * {@link jakarta.servlet.ServletRequestListener}, {@link jakarta.servlet.ServletRequestAttributeListener},
     * {@link jakarta.servlet.http.HttpSessionListener}, or {@link jakarta.servlet.http.HttpSessionAttributeListener}, or
     * {@link jakarta.servlet.http.HttpSessionIdListener} interfaces.
     */
    public void setWebListeners(EventListener[] eventListeners) {
        if (eventListeners != null) {
            for (EventListener eventListener : eventListeners) {
                addEventListener(eventListener);
            }
        }
    }

    public void setServlets(JettyServlet[] servlets) {
        if (servlets != null) {
            for (JettyServlet servlet : servlets) {
                getServletHandler().addServlet(servlet);
                ServletMapping mapping = new ServletMapping();
                mapping.setServletName(servlet.getName());
                mapping.setPathSpecs(servlet.getMappings());
                getServletHandler().addServletMapping(mapping);
            }
        }
    }

    public void setFilters(JettyFilter[] jettyFilters) {
        if (jettyFilters != null) {
            for (JettyFilter jettyFilter : jettyFilters) {
                getServletHandler().addFilter(jettyFilter);
                if (jettyFilter.getUrlMappings() != null) {
                    for (JettyFilterUrlMapping urlMapping : jettyFilter.getUrlMappings()) {
                        getServletHandler().addFilterMapping(urlMapping);
                    }
                }
                if (jettyFilter.getServletMappings() != null) {
                    for (JettyFilterServletMapping servletMapping : jettyFilter.getServletMappings()) {
                        getServletHandler().addFilterMapping(servletMapping);
                    }
                }
            }
        }
    }

    public void setErrorPages(JettyErrorPage[] errorPages) {
        if (errorPages != null && errorPages.length > 0) {
            this.errorPages = Arrays.asList(errorPages);
        } else {
            this.errorPages = null;
        }
    }

    public void setServletContainerInitializers(ServletContainerInitializer[] servletContainerInitializers) {
        Assert.notNull(servletContainerInitializers, "servletContainerInitializers must not be null");
        for (ServletContainerInitializer initializer : servletContainerInitializers) {
            addServletContainerInitializer(initializer);
        }
    }

    public void setWebSocketInitializer(JettyWebSocketInitializer webSocketInitializer) {
        this.webSocketInitializer = webSocketInitializer;
    }

    public void deferredInitialize(Server server) {
        WebAppClassLoader webAppClassLoader = new WebAppClassLoader(getActivityContext().getClassLoader(), this);
        setClassLoader(webAppClassLoader);

        if (errorPages != null) {
            ErrorPageErrorHandler errorHandler = new ErrorPageErrorHandler();
            for (JettyErrorPage errorPage : errorPages) {
                if (StringUtils.hasText(errorPage.getLocation())) {
                    if (errorPage.getErrorCode() != null) {
                        if (errorPage.getToErrorCode() != null) {
                            errorHandler.addErrorPage(errorPage.getErrorCode(), errorPage.getToErrorCode(), errorPage.getLocation());
                        } else {
                            errorHandler.addErrorPage(errorPage.getErrorCode(), errorPage.getLocation());
                        }
                    } else if (errorPage.getExceptionType() != null) {
                        errorHandler.addErrorPage(errorPage.getExceptionType(), errorPage.getLocation());
                    }
                }
            }
            setErrorHandler(errorHandler);
        }

        if (webSocketInitializer != null) {
            JakartaWebSocketServletContainerInitializer.configure(this,
                    (servletContext, jettyWebSocketServerContainer) -> {
                        ServerContainer serverContainer = JakartaWebSocketServerContainer.ensureContainer(servletContext);
                        webSocketInitializer.customize(serverContainer);
                    });
        }

        // Create a root web service
        CoreService masterService = getActivityContext().getMasterService();
        WebService rootWebService = DefaultWebServiceBuilder.build(getServletContext(), masterService);
        if (rootWebService.isOrphan()) {
            server.addEventListener(new LifeCycle.Listener() {
                @Override
                public void lifeCycleStarted(LifeCycle event) {
                    try {
                        rootWebService.getServiceLifeCycle().start();
                    } catch (Exception e) {
                        logger.error("Failed to start root web service", e);
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }

    public void deferredDispose() {
        DefaultWebService webService = WebService.findWebService(getServletContext());
        if (webService.isActive()) {
            webService.stop();
        }
        webService.withdraw();
    }

}

1	/*
2	* Copyright (c) 2008-2025 The Aspectran Project
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.aspectran.jetty.server.servlet;
17
18	import com.aspectran.core.component.bean.annotation.AvoidAdvice;
19	import com.aspectran.core.component.bean.aware.ActivityContextAware;
20	import com.aspectran.core.context.ActivityContext;
21	import com.aspectran.core.service.CoreService;
22	import com.aspectran.utils.Assert;
23	import com.aspectran.utils.StringUtils;
24	import com.aspectran.utils.annotation.jsr305.NonNull;
25	import com.aspectran.utils.logging.Logger;
26	import com.aspectran.utils.logging.LoggerFactory;
27	import com.aspectran.web.service.DefaultWebService;
28	import com.aspectran.web.service.DefaultWebServiceBuilder;
29	import com.aspectran.web.service.WebService;
30	import jakarta.servlet.ServletContainerInitializer;
31	import jakarta.websocket.server.ServerContainer;
32	import org.eclipse.jetty.ee10.servlet.ErrorPageErrorHandler;
33	import org.eclipse.jetty.ee10.servlet.ServletMapping;
34	import org.eclipse.jetty.ee10.webapp.WebAppClassLoader;
35	import org.eclipse.jetty.ee10.webapp.WebAppContext;
36	import org.eclipse.jetty.ee10.webapp.WebXmlConfiguration;
37	import org.eclipse.jetty.ee10.websocket.jakarta.server.JakartaWebSocketServerContainer;
38	import org.eclipse.jetty.ee10.websocket.jakarta.server.config.JakartaWebSocketServletContainerInitializer;
39	import org.eclipse.jetty.server.Server;
40	import org.eclipse.jetty.util.component.LifeCycle;
41	import org.eclipse.jetty.util.resource.Resource;
42	import org.eclipse.jetty.util.resource.Resources;
43
44	import java.io.File;
45	import java.io.IOException;
46	import java.net.URI;
47	import java.net.URL;
48	import java.util.Arrays;
49	import java.util.EventListener;
50	import java.util.List;
51	import java.util.Map;
52
53	/**
54	* The Class JettyWebAppContext.
55	*
56	* <p>Created: 2017. 1. 27.</p>
57	*/
58	public class JettyWebAppContext extends WebAppContext implements ActivityContextAware {	1✔
59
60	private static final Logger logger = LoggerFactory.getLogger(JettyWebAppContext.class);	1✔
61
62	private ActivityContext context;
63
64	private List<JettyErrorPage> errorPages;
65
66	private JettyWebSocketInitializer webSocketInitializer;
67
68	@NonNull
69	private ActivityContext getActivityContext() {
70	Assert.state(context != null, "No ActivityContext injected");	1✔
71	return context;	1✔
72	}
73
74	@Override
75	@AvoidAdvice
76	public void setActivityContext(@NonNull ActivityContext context) {
77	this.context = context;	1✔
78	}	1✔
79
80	@Override
81	public void setWar(String war) {
82	try {
83	File warFile = new File(war);	1✔
84	if (warFile.isDirectory()) {	1✔
85	if (!warFile.exists() && !warFile.mkdirs()) {	1✔
NEW 86	throw new IOException("Unable to create WAR directory: " + warFile);	×
87	}
88	}
89	super.setWar(warFile.getCanonicalPath());	1✔
90	} catch (Exception e) {	×
NEW 91	logger.error("Failed to establish WAR of the webapp: " + war, e);	×
92	}	1✔
93	}	1✔
94
95	public void setTempDirectory(String tempDirectory) {
96	try {
97	File tempDir = new File(tempDirectory);	1✔
98	if (!tempDir.exists()) {	1✔
99	if (!tempDir.mkdirs()) {	1✔
100	throw new IOException("Unable to create scratch directory: " + tempDir);	×
101	}
102	}
103	super.setTempDirectory(tempDir.getCanonicalFile());	1✔
104	} catch (Exception e) {	×
NEW 105	logger.error("Failed to establish scratch directory: " + tempDirectory, e);	×
106	}	1✔
107	}	1✔
108
109	@Override
110	public void setDefaultsDescriptor(String defaultsDescriptor) {
111	if (StringUtils.hasLength(defaultsDescriptor)) {	1✔
112	Resource dftResource;
113	try {
114	dftResource = getResourceFactory().newClassLoaderResource(defaultsDescriptor);	1✔
115	if (Resources.missing(dftResource)) {	1✔
116	String pkg = WebXmlConfiguration.class.getPackageName().replace(".", "/") + "/";	×
117	if (defaultsDescriptor.startsWith(pkg)) {	×
118	URL url = WebXmlConfiguration.class.getResource(defaultsDescriptor.substring(pkg.length()));	×
119	if (url != null) {	×
120	URI uri = url.toURI();	×
121	dftResource = getResourceFactory().newResource(uri);	×
122	}
123	}
124	if (Resources.missing(dftResource)) {	×
125	dftResource = newResource(defaultsDescriptor);	×
126	}
127	}
128	} catch (Exception e) {	×
129	throw new IllegalArgumentException("Invalid default descriptor: " + defaultsDescriptor, e);	×
130	}	1✔
131	if (Resources.isReadableFile(dftResource)) {	1✔
132	super.setDefaultsDescriptor(defaultsDescriptor);	1✔
133	} else {
134	throw new IllegalArgumentException("Unable to locate default descriptor: " + defaultsDescriptor);	×
135	}
136	}
137	}	1✔
138
139	public void setInitParams(Map<String, String> initParams) {
140	if (initParams != null) {	×
141	for (Map.Entry<String, String> entry : initParams.entrySet()) {	×
142	setInitParameter(entry.getKey(), entry.getValue());	×
143	}	×
144	}
145	}	×
146
147	public void setListeners(JettyListener[] jettyListeners) {
148	if (jettyListeners != null) {	1✔
149	for (JettyListener jettyListener : jettyListeners) {	1✔
150	getServletHandler().addListener(jettyListener);	1✔
151	}
152	}
153	}	1✔
154
155	/**
156	* Any event listeners added as WebListener must implement one or more of the
157	* {@link jakarta.servlet.ServletContextListener}, {@link jakarta.servlet.ServletContextAttributeListener},
158	* {@link jakarta.servlet.ServletRequestListener}, {@link jakarta.servlet.ServletRequestAttributeListener},
159	* {@link jakarta.servlet.http.HttpSessionListener}, or {@link jakarta.servlet.http.HttpSessionAttributeListener}, or
160	* {@link jakarta.servlet.http.HttpSessionIdListener} interfaces.
161	*/
162	public void setWebListeners(EventListener[] eventListeners) {
163	if (eventListeners != null) {	×
164	for (EventListener eventListener : eventListeners) {	×
165	addEventListener(eventListener);	×
166	}
167	}
168	}	×
169
170	public void setServlets(JettyServlet[] servlets) {
171	if (servlets != null) {	1✔
172	for (JettyServlet servlet : servlets) {	1✔
173	getServletHandler().addServlet(servlet);	1✔
174	ServletMapping mapping = new ServletMapping();	1✔
175	mapping.setServletName(servlet.getName());	1✔
176	mapping.setPathSpecs(servlet.getMappings());	1✔
177	getServletHandler().addServletMapping(mapping);	1✔
178	}
179	}
180	}	1✔
181
182	public void setFilters(JettyFilter[] jettyFilters) {
183	if (jettyFilters != null) {	1✔
184	for (JettyFilter jettyFilter : jettyFilters) {	1✔
185	getServletHandler().addFilter(jettyFilter);	1✔
186	if (jettyFilter.getUrlMappings() != null) {	1✔
187	for (JettyFilterUrlMapping urlMapping : jettyFilter.getUrlMappings()) {	×
188	getServletHandler().addFilterMapping(urlMapping);	×
189	}
190	}
191	if (jettyFilter.getServletMappings() != null) {	1✔
192	for (JettyFilterServletMapping servletMapping : jettyFilter.getServletMappings()) {	1✔
193	getServletHandler().addFilterMapping(servletMapping);	1✔
194	}
195	}
196	}
197	}
198	}	1✔
199
200	public void setErrorPages(JettyErrorPage[] errorPages) {
201	if (errorPages != null && errorPages.length > 0) {	×
202	this.errorPages = Arrays.asList(errorPages);	×
203	} else {
204	this.errorPages = null;	×
205	}
206	}	×
207
208	public void setServletContainerInitializers(ServletContainerInitializer[] servletContainerInitializers) {
209	Assert.notNull(servletContainerInitializers, "servletContainerInitializers must not be null");	1✔
210	for (ServletContainerInitializer initializer : servletContainerInitializers) {	1✔
211	addServletContainerInitializer(initializer);	1✔
212	}
213	}	1✔
214
215	public void setWebSocketInitializer(JettyWebSocketInitializer webSocketInitializer) {
216	this.webSocketInitializer = webSocketInitializer;	1✔
217	}	1✔
218
219	public void deferredInitialize(Server server) {
220	WebAppClassLoader webAppClassLoader = new WebAppClassLoader(getActivityContext().getClassLoader(), this);	1✔
221	setClassLoader(webAppClassLoader);	1✔
222
223	if (errorPages != null) {	1✔
224	ErrorPageErrorHandler errorHandler = new ErrorPageErrorHandler();	×
225	for (JettyErrorPage errorPage : errorPages) {	×
226	if (StringUtils.hasText(errorPage.getLocation())) {	×
227	if (errorPage.getErrorCode() != null) {	×
228	if (errorPage.getToErrorCode() != null) {	×
229	errorHandler.addErrorPage(errorPage.getErrorCode(), errorPage.getToErrorCode(), errorPage.getLocation());	×
230	} else {
231	errorHandler.addErrorPage(errorPage.getErrorCode(), errorPage.getLocation());	×
232	}
233	} else if (errorPage.getExceptionType() != null) {	×
234	errorHandler.addErrorPage(errorPage.getExceptionType(), errorPage.getLocation());	×
235	}
236	}
237	}	×
238	setErrorHandler(errorHandler);	×
239	}
240
241	if (webSocketInitializer != null) {	1✔
242	JakartaWebSocketServletContainerInitializer.configure(this,	1✔
243	(servletContext, jettyWebSocketServerContainer) -> {
244	ServerContainer serverContainer = JakartaWebSocketServerContainer.ensureContainer(servletContext);	1✔
245	webSocketInitializer.customize(serverContainer);	1✔
246	});	1✔
247	}
248
249	// Create a root web service
250	CoreService masterService = getActivityContext().getMasterService();	1✔
251	WebService rootWebService = DefaultWebServiceBuilder.build(getServletContext(), masterService);	1✔
252	if (rootWebService.isOrphan()) {	1✔
253	server.addEventListener(new LifeCycle.Listener() {	1✔
254	@Override
255	public void lifeCycleStarted(LifeCycle event) {
256	try {
257	rootWebService.getServiceLifeCycle().start();	1✔
258	} catch (Exception e) {	×
259	logger.error("Failed to start root web service", e);	×
260	throw new RuntimeException(e);	×
261	}	1✔
262	}	1✔
263	});
264	}
265	}	1✔
266
267	public void deferredDispose() {
268	DefaultWebService webService = WebService.findWebService(getServletContext());	1✔
269	if (webService.isActive()) {	1✔
270	webService.stop();	1✔
271	}
272	webService.withdraw();	1✔
273	}	1✔
274
275	}

aspectran / aspectran / #3993

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous