| /******************************************************************************* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| *******************************************************************************/ |
| package org.ofbiz.jetty.container; |
| |
| import java.io.File; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.ofbiz.base.component.ComponentConfig; |
| import org.ofbiz.base.container.Container; |
| import org.ofbiz.base.container.ContainerConfig; |
| import org.ofbiz.base.container.ContainerException; |
| import org.ofbiz.base.util.Debug; |
| import org.ofbiz.base.util.SSLUtil; |
| import org.ofbiz.base.util.UtilProperties; |
| import org.ofbiz.base.util.UtilValidate; |
| |
| import org.eclipse.jetty.ajp.Ajp13SocketConnector; |
| import org.eclipse.jetty.server.Connector; |
| import org.eclipse.jetty.server.NCSARequestLog; |
| import org.eclipse.jetty.server.Server; |
| import org.eclipse.jetty.server.bio.SocketConnector; |
| import org.eclipse.jetty.server.handler.HandlerCollection; |
| import org.eclipse.jetty.server.handler.RequestLogHandler; |
| import org.eclipse.jetty.server.nio.SelectChannelConnector; |
| import org.eclipse.jetty.server.session.HashSessionManager; |
| import org.eclipse.jetty.server.session.SessionHandler; |
| import org.eclipse.jetty.server.ssl.SslConnector; |
| import org.eclipse.jetty.server.ssl.SslSelectChannelConnector; |
| import org.eclipse.jetty.server.ssl.SslSocketConnector; |
| import org.eclipse.jetty.util.ssl.SslContextFactory; |
| import org.eclipse.jetty.util.thread.QueuedThreadPool; |
| import org.eclipse.jetty.util.thread.ThreadPool; |
| import org.eclipse.jetty.webapp.WebAppContext; |
| |
| |
| /** |
| * JettyContainer - Container implementation for Jetty |
| */ |
| public class JettyContainer implements Container { |
| |
| public static final String module = JettyContainer.class.getName(); |
| |
| private Map<String, Server> servers = new HashMap<String, Server>(); |
| |
| /** |
| * @see org.ofbiz.base.container.Container#init(java.lang.String[], java.lang.String) |
| */ |
| public void init(String[] args, String configFile) throws ContainerException { |
| |
| // configure JSSE properties |
| SSLUtil.loadJsseProperties(); |
| |
| // session store directory |
| File sessionStoreDirectory = new File(UtilProperties.getPropertyValue("jetty", "session.store.directory", "runtime/jetty/sessions")); |
| if (!sessionStoreDirectory.exists()) { |
| if (!sessionStoreDirectory.mkdirs()) { |
| throw new ContainerException("error creating session store directory: " + sessionStoreDirectory.getAbsolutePath()); |
| } |
| } |
| |
| // get the jetty container config |
| ContainerConfig.Container jettyContainerConfig = ContainerConfig.getContainer("jetty-container", configFile); |
| |
| // create the servers |
| for (ContainerConfig.Container.Property serverConfig : jettyContainerConfig.getPropertiesWithValue("server")) { |
| servers.put(serverConfig.name, createServer(serverConfig)); |
| } |
| |
| // create the webapp contexts |
| for (ComponentConfig componentConfig : ComponentConfig.getAllComponents()) { |
| |
| for (ComponentConfig.WebappInfo webappInfo : componentConfig.getWebappInfos()) { |
| |
| Server server = servers.get(webappInfo.server); |
| if (server == null) { |
| |
| Debug.logError("Server with name [" + webappInfo.server + "] not found; not mounting [" + webappInfo.name + "]", module); |
| |
| } else { |
| |
| // set the root location (make sure we set the paths correctly) |
| String location = componentConfig.getRootLocation() + webappInfo.location; |
| location = location.replace('\\', '/'); |
| if (location.endsWith("/")) { |
| location = location.substring(0, location.lastIndexOf("/")); |
| } |
| |
| String mountPoint = webappInfo.mountPoint; |
| if (mountPoint.endsWith("/*")) { |
| mountPoint = mountPoint.substring(0, mountPoint.lastIndexOf("/")); |
| } |
| |
| WebAppContext context = new WebAppContext(location, mountPoint); |
| context.setAttribute("_serverId", webappInfo.server); |
| context.setLogUrlOnStart(true); |
| |
| // set the session manager |
| HashSessionManager sm = new HashSessionManager(); |
| sm.setStoreDirectory(sessionStoreDirectory); |
| sm.setLazyLoad(true); |
| context.setSessionHandler(new SessionHandler(sm)); |
| |
| // set the virtual hosts |
| List<String> virtualHosts = webappInfo.getVirtualHosts(); |
| if (UtilValidate.isNotEmpty(virtualHosts)) { |
| context.setVirtualHosts(virtualHosts.toArray(new String[virtualHosts.size()])); |
| } |
| |
| // set the init parameters |
| Map<String, String> initParameters = webappInfo.getInitParameters(); |
| if (UtilValidate.isNotEmpty(initParameters)) { |
| for (Map.Entry<String, String> e : initParameters.entrySet()) { |
| context.setInitParameter(e.getKey(), e.getValue()); |
| } |
| } |
| |
| ((HandlerCollection) server.getHandler()).addHandler(context); |
| } |
| } |
| } |
| } |
| |
| private Server createServer(ContainerConfig.Container.Property serverConfig) { |
| |
| Server server = new Server(); |
| server.setHandler(new HandlerCollection()); |
| |
| // send server version? |
| if (UtilValidate.isNotEmpty(serverConfig.getProperty("send-server-version"))) { |
| String sendServerVersionPropertyValue = serverConfig.getProperty("send-server-version").value; |
| try { |
| server.setSendServerVersion(Boolean.parseBoolean(sendServerVersionPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for send-server-version: " + sendServerVersionPropertyValue, module); |
| } |
| } |
| |
| // thread pool |
| server.setThreadPool(createThreadPool(serverConfig)); |
| |
| // connectors |
| for (ContainerConfig.Container.Property connectorConfig : serverConfig.getPropertiesWithValue("connector")) { |
| |
| Connector connector = null; |
| |
| String connectorType = connectorConfig.getProperty("type").value; |
| |
| if ("http".equals(connectorType)) { |
| connector = new SocketConnector(); |
| } else if ("https".equals(connectorType)) { |
| connector = new SslSocketConnector(); |
| } else if ("nio-http".equals(connectorType)) { |
| connector = new SelectChannelConnector(); |
| } else if ("nio-https".equals(connectorType)) { |
| connector = new SslSelectChannelConnector(); |
| } else if ("ajp13".equals(connectorType)) { |
| connector = new Ajp13SocketConnector(); |
| } |
| |
| if (connector != null) { |
| setConnectorOptions(connector, connectorConfig); |
| server.addConnector(connector); |
| } |
| } |
| |
| // request logs |
| for (ContainerConfig.Container.Property props : serverConfig.getPropertiesWithValue("request-log")) { |
| |
| NCSARequestLog requestLog = new NCSARequestLog(); |
| |
| if (UtilValidate.isNotEmpty(props.getProperty("filename"))) { |
| requestLog.setFilename(props.getProperty("filename").value); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("append"))) { |
| requestLog.setAppend("true".equalsIgnoreCase(props.getProperty("append").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("extended"))) { |
| requestLog.setExtended("true".equalsIgnoreCase(props.getProperty("extended").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("log-dispatch"))) { |
| requestLog.setLogDispatch("true".equalsIgnoreCase(props.getProperty("log-dispatch").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("log-latency"))) { |
| requestLog.setLogLatency("true".equalsIgnoreCase(props.getProperty("log-latency").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("log-server"))) { |
| requestLog.setLogServer("true".equalsIgnoreCase(props.getProperty("log-server").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("prefer-proxied-for-address"))) { |
| requestLog.setPreferProxiedForAddress("true".equalsIgnoreCase(props.getProperty("prefer-proxied-for-address").value)); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("timezone"))) { |
| requestLog.setLogTimeZone(props.getProperty("timezone").value); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("date-format"))) { |
| requestLog.setLogDateFormat(props.getProperty("date-format").value); |
| } |
| if (UtilValidate.isNotEmpty(props.getProperty("retain-days"))) { |
| String retainDaysPropertyValue = props.getProperty("retain-days").value; |
| try { |
| requestLog.setRetainDays(Integer.parseInt(retainDaysPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for retain-days: " + retainDaysPropertyValue, module); |
| } |
| } |
| |
| RequestLogHandler requestLogHandler = new RequestLogHandler(); |
| requestLogHandler.setRequestLog(requestLog); |
| |
| ((HandlerCollection) server.getHandler()).addHandler(requestLogHandler); |
| } |
| |
| return server; |
| } |
| |
| private ThreadPool createThreadPool(ContainerConfig.Container.Property serverConfig) { |
| |
| QueuedThreadPool threadPool = new QueuedThreadPool(); |
| |
| if (UtilValidate.isNotEmpty(serverConfig.getProperty("min-threads"))) { |
| String minThreadsPropertyValue = serverConfig.getProperty("min-threads").value; |
| try { |
| threadPool.setMinThreads(Integer.parseInt(minThreadsPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for min-threads: " + minThreadsPropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(serverConfig.getProperty("max-threads"))) { |
| String maxThreadsPropertyValue = serverConfig.getProperty("max-threads").value; |
| try { |
| threadPool.setMaxThreads(Integer.parseInt(maxThreadsPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for max-threads: " + maxThreadsPropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(serverConfig.getProperty("max-idle-time-ms"))) { |
| String maxIdleTimeMsPropertyValue = serverConfig.getProperty("max-idle-time-ms").value; |
| try { |
| threadPool.setMaxIdleTimeMs(Integer.parseInt(maxIdleTimeMsPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for max-idle-time-ms: " + maxIdleTimeMsPropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(serverConfig.getProperty("max-stop-time-ms"))) { |
| String maxStopTimeMsPropertyValue = serverConfig.getProperty("max-stop-time-ms").value; |
| try { |
| threadPool.setMaxStopTimeMs(Integer.parseInt(maxStopTimeMsPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for max-stop-time-ms: " + maxStopTimeMsPropertyValue, module); |
| } |
| } |
| |
| return threadPool; |
| } |
| |
| private void setConnectorOptions(Connector connector, ContainerConfig.Container.Property connectorConfig) { |
| |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("host"))) { |
| connector.setHost(connectorConfig.getProperty("host").value); |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("port"))) { |
| String portPropertyValue = connectorConfig.getProperty("port").value; |
| try { |
| connector.setPort(Integer.parseInt(portPropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for port: " + portPropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("request-buffer-size"))) { |
| String requestBufferSizePropertyValue = connectorConfig.getProperty("request-buffer-size").value; |
| try { |
| connector.setRequestBufferSize(Integer.parseInt(requestBufferSizePropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for request-buffer-size: " + requestBufferSizePropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("request-header-size"))) { |
| String requestHeaderSizePropertyValue = connectorConfig.getProperty("request-header-size").value; |
| try { |
| connector.setRequestHeaderSize(Integer.parseInt(requestHeaderSizePropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for request-header-size: " + requestHeaderSizePropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("response-buffer-size"))) { |
| String responseBufferSizePropertyValue = connectorConfig.getProperty("response-buffer-size").value; |
| try { |
| connector.setResponseBufferSize(Integer.parseInt(responseBufferSizePropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for response-buffer-size: " + responseBufferSizePropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("response-header-size"))) { |
| String responseHeaderSizePropertyValue = connectorConfig.getProperty("response-header-size").value; |
| try { |
| connector.setResponseHeaderSize(Integer.parseInt(responseHeaderSizePropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for response-header-size: " + responseHeaderSizePropertyValue, module); |
| } |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("low-resource-max-idle-time"))) { |
| String lowResourceMaxIdleTimePropertyValue = connectorConfig.getProperty("low-resource-max-idle-time").value; |
| try { |
| connector.setLowResourceMaxIdleTime(Integer.parseInt(lowResourceMaxIdleTimePropertyValue)); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "invalid value for low-resource-max-idle-time: " + lowResourceMaxIdleTimePropertyValue, module); |
| } |
| } |
| |
| // SSL options |
| if (connector instanceof SslConnector) { |
| |
| SslContextFactory cf = ((SslConnector) connector).getSslContextFactory(); |
| |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("keystore"))) { |
| cf.setKeyStorePath(connectorConfig.getProperty("keystore").value); |
| } |
| if (connectorConfig.getProperty("password") != null) { |
| cf.setKeyStorePassword(connectorConfig.getProperty("password").value); |
| } |
| if (connectorConfig.getProperty("key-password") != null) { |
| cf.setKeyManagerPassword(connectorConfig.getProperty("key-password").value); |
| } |
| if (UtilValidate.isNotEmpty(connectorConfig.getProperty("client-auth"))) { |
| if ("need".equals(connectorConfig.getProperty("client-auth").value)) { |
| cf.setNeedClientAuth(true); |
| } else if ("want".equals(connectorConfig.getProperty("client-auth").value)) { |
| cf.setWantClientAuth(true); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @see org.ofbiz.base.container.Container#start() |
| */ |
| public boolean start() throws ContainerException { |
| for (Server server : servers.values()) { |
| try { |
| server.start(); |
| } catch (Exception e) { |
| throw new ContainerException(e); |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * @see org.ofbiz.base.container.Container#stop() |
| */ |
| public void stop() throws ContainerException { |
| for (Server server : servers.values()) { |
| try { |
| server.stop(); |
| } catch (Exception e) { |
| throw new ContainerException(e); |
| } |
| } |
| } |
| |
| } |
