Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Jetty9 - Introduced ConnectionFactory for SelectChannelConnector. 

This change abstracts out the connection creation from the connector itself,
so there can be only one connector managing all protocols, depending on
the configuration of the connection factories.
This commit is contained in:
Simone Bordet 2012-08-03 18:35:34 +02:00
parent 2d7b6c9c06
commit e3132d41d8
49 changed files with 1052 additions and 1196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
example-jetty-embedded/src/main/java/org/eclipse/jetty/embedded/LikeJettyXml.java
View File

@ -22,6 +22,8 @@ import org.eclipse.jetty.jmx.MBeanContainer;
import org.eclipse.jetty.security.HashLoginService;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpServerConnectionFactory;
import org.eclipse.jetty.server.NCSARequestLog;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
@ -44,7 +46,7 @@ public class LikeJettyXml
// Setup Threadpool
QueuedThreadPool threadPool = new QueuedThreadPool();
threadPool.setMaxThreads(500);
Server server = new Server(threadPool);
server.manage(threadPool);
server.setDumpAfterStart(true);
@ -61,33 +63,35 @@ public class LikeJettyXml
SelectChannelConnector connector = new SelectChannelConnector(server);
connector.setPort(8080);
connector.setIdleTimeout(30000);
connector.getConnectionFactory().getHttpConfig().setConfidentialPort(8443);
HttpConfiguration httpConfiguration = new HttpConfiguration(null, false);
httpConfiguration.setConfidentialPort(8443);
connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(connector, httpConfiguration));
// TODO connector.setStatsOn(false);
server.setConnectors(new Connector[]
{ connector });
SelectChannelConnector ssl_connector = new SelectChannelConnector(server,true);
ssl_connector.setPort(8443);
SslContextFactory cf = ssl_connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(jetty_home + "/etc/keystore");
cf.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
cf.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
cf.setTrustStore(jetty_home + "/etc/keystore");
cf.setTrustStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
cf.setExcludeCipherSuites(
new String[] {
"SSL_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_DSS_WITH_DES_CBC_SHA",
"SSL_RSA_EXPORT_WITH_RC4_40_MD5",
"SSL_RSA_EXPORT_WITH_DES40_CBC_SHA",
"SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
"SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(jetty_home + "/etc/keystore");
sslContextFactory.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
sslContextFactory.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
sslContextFactory.setTrustStore(jetty_home + "/etc/keystore");
sslContextFactory.setTrustStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
sslContextFactory.setExcludeCipherSuites(
new String[]{
"SSL_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_DSS_WITH_DES_CBC_SHA",
"SSL_RSA_EXPORT_WITH_RC4_40_MD5",
"SSL_RSA_EXPORT_WITH_DES40_CBC_SHA",
"SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
"SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"
});
// TODO ssl_connector.setStatsOn(false);
server.addConnector(ssl_connector);
ssl_connector.open();
SelectChannelConnector sslConnector = new SelectChannelConnector(server,sslContextFactory);
sslConnector.setPort(8443);
// TODO sslConnector.setStatsOn(false);
server.addConnector(sslConnector);
sslConnector.open();
HandlerCollection handlers = new HandlerCollection();
ContextHandlerCollection contexts = new ContextHandlerCollection();

16
example-jetty-embedded/src/main/java/org/eclipse/jetty/embedded/ManyConnectors.java
View File

@ -38,17 +38,17 @@ public class ManyConnectors
connector1.setPort(8888);
connector1.setName("admin");
SelectChannelConnector ssl_connector = new SelectChannelConnector(server,true);
String jetty_home = System.getProperty("jetty.home","../jetty-distribution/target/distribution");
System.setProperty("jetty.home",jetty_home);
ssl_connector.setPort(8443);
SslContextFactory cf = ssl_connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(jetty_home + "/etc/keystore");
cf.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
cf.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
System.setProperty("jetty.home", jetty_home);
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(jetty_home + "/etc/keystore");
sslContextFactory.setKeyStorePassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
sslContextFactory.setKeyManagerPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
SelectChannelConnector sslConnector = new SelectChannelConnector(server,sslContextFactory);
sslConnector.setPort(8443);
server.setConnectors(new Connector[]
{ connector0, connector1, ssl_connector });
{ connector0, connector1, sslConnector });
server.setHandler(new HelloHandler());

7
jetty-deploy/src/test/java/org/eclipse/jetty/deploy/test/XmlConfiguredJetty.java
View File

@ -36,6 +36,7 @@ import org.eclipse.jetty.deploy.DeploymentManager;
import org.eclipse.jetty.http.HttpScheme;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
@ -65,7 +66,7 @@ public class XmlConfiguredJetty
Properties properties = new Properties();
String jettyHomeBase = testdir.getDir().getAbsolutePath();
// Ensure we have a new (pristene) directory to work with.
// Ensure we have a new (pristene) directory to work with.
int idx = 0;
_jettyHome = new File(jettyHomeBase + "#" + idx);
while (_jettyHome.exists())
@ -412,9 +413,9 @@ public class XmlConfiguredJetty
Connector connectors[] = _server.getConnectors();
for (int i = 0; _serverPort<0 && i < connectors.length; i++)
{
if (connectors[i] instanceof Connector.NetConnector)
if (connectors[i] instanceof NetworkConnector)
{
int port = ((Connector.NetConnector)connectors[i]).getLocalPort();
int port = ((NetworkConnector)connectors[i]).getLocalPort();
if (port>0)
_serverPort=port;
}

16
jetty-io/src/test/java/org/eclipse/jetty/io/SelectChannelEndPointInterestsTest.java
View File

@ -33,6 +33,7 @@ import java.util.concurrent.atomic.AtomicReference;
import org.eclipse.jetty.util.BufferUtil;
import org.eclipse.jetty.util.Callback;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
@ -86,7 +87,7 @@ public class SelectChannelEndPointInterestsTest
super.onOpen();
fillInterested();
}
@Override
public void onFillable()
{
@ -98,6 +99,19 @@ public class SelectChannelEndPointInterestsTest
selectorManager.start();
}
@After
public void destroy() throws Exception
{
if (selectorManager != null)
selectorManager.stop();
if (connector != null)
connector.close();
if (scheduler != null)
scheduler.shutdownNow();
if (threadPool != null)
threadPool.stop();
}
@Test
public void testReadBlockedThenWriteBlockedThenReadableThenWritable() throws Exception
{

21
jetty-io/src/test/java/org/eclipse/jetty/io/SelectChannelEndPointSslTest.java
View File

@ -1,11 +1,5 @@
package org.eclipse.jetty.io;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
@ -13,7 +7,6 @@ import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLEngineResult;
import javax.net.ssl.SSLEngineResult.HandshakeStatus;
@ -28,6 +21,12 @@ import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class SelectChannelEndPointSslTest extends SelectChannelEndPointTest
{
@ -55,7 +54,7 @@ public class SelectChannelEndPointSslTest extends SelectChannelEndPointTest
@Override
protected Connection newConnection(SocketChannel channel, EndPoint endpoint)
{
SSLEngine engine = __sslCtxFactory.newSslEngine();
SSLEngine engine = __sslCtxFactory.newSSLEngine();
engine.setUseClientMode(false);
SslConnection sslConnection = new SslConnection(__byteBufferPool, _threadPool, endpoint, engine);
@ -94,7 +93,7 @@ public class SelectChannelEndPointSslTest extends SelectChannelEndPointTest
server.configureBlocking(false);
_manager.accept(server);
SSLEngine engine = __sslCtxFactory.newSslEngine();
SSLEngine engine = __sslCtxFactory.newSSLEngine();
engine.setUseClientMode(true);
engine.beginHandshake();
@ -263,8 +262,8 @@ public class SelectChannelEndPointSslTest extends SelectChannelEndPointTest
@Test
public void checkSslEngineBehaviour() throws Exception
{
SSLEngine server = __sslCtxFactory.newSslEngine();
SSLEngine client = __sslCtxFactory.newSslEngine();
SSLEngine server = __sslCtxFactory.newSSLEngine();
SSLEngine client = __sslCtxFactory.newSSLEngine();
ByteBuffer netC2S = ByteBuffer.allocate(server.getSession().getPacketBufferSize());
ByteBuffer netS2C = ByteBuffer.allocate(server.getSession().getPacketBufferSize());

6
jetty-io/src/test/java/org/eclipse/jetty/io/SslConnectionTest.java
View File

@ -13,12 +13,10 @@ import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLSocket;
import junit.framework.Assert;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
import org.eclipse.jetty.util.BufferUtil;
@ -52,7 +50,7 @@ public class SslConnectionTest
@Override
public Connection newConnection(SocketChannel channel, EndPoint endpoint, Object attachment)
{
SSLEngine engine = __sslCtxFactory.newSslEngine();
SSLEngine engine = __sslCtxFactory.newSSLEngine();
engine.setUseClientMode(false);
SslConnection sslConnection = new SslConnection(__byteBufferPool, _threadPool, endpoint, engine);
@ -120,7 +118,7 @@ public class SslConnectionTest
super.onOpen();
fillInterested();
}
@Override
public void onClose()
{

25
jetty-security/src/test/java/org/eclipse/jetty/security/DataConstraintsTest.java
View File

@ -13,12 +13,8 @@
package org.eclipse.jetty.security;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
import java.io.IOException;
import java.util.Arrays;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -28,6 +24,7 @@ import org.eclipse.jetty.http.HttpScheme;
import org.eclipse.jetty.security.authentication.BasicAuthenticator;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpServerConnectionFactory;
import org.eclipse.jetty.server.LocalConnector;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
@ -40,6 +37,9 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
/**
* @version $Revision: 1441 $ $Date: 2010-04-02 12:28:17 +0200 (Fri, 02 Apr 2010) $
*/
@ -57,12 +57,15 @@ public class DataConstraintsTest
_server = new Server();
_connector = new LocalConnector(_server);
_connector.setIdleTimeout(300000);
_connector.getConnectionFactory().getHttpConfig().setIntegralPort(9998);
_connector.getConnectionFactory().getHttpConfig().setIntegralScheme("FTP");
_connector.getConnectionFactory().getHttpConfig().setConfidentialPort(9999);
_connector.getConnectionFactory().getHttpConfig().setConfidentialScheme("SPDY");
_connectorS = new LocalConnector(_server,
new HttpConfiguration(null,false)
HttpConfiguration httpConfiguration = new HttpConfiguration(null, false);
httpConfiguration.setIntegralPort(9998);
httpConfiguration.setIntegralScheme("FTP");
httpConfiguration.setConfidentialPort(9999);
httpConfiguration.setConfidentialScheme("SPDY");
_connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(_connector, httpConfiguration));
_connectorS = new LocalConnector(_server);
_connectorS.setDefaultConnectionFactory(new HttpServerConnectionFactory(_connectorS, new HttpConfiguration(null,false)
{
@Override
public void customize(Request request) throws IOException
@ -83,7 +86,7 @@ public class DataConstraintsTest
{
return true;
}
});
}));
_server.setConnectors(new Connector[]{_connector,_connectorS});
ContextHandler _context = new ContextHandler();

257
jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java
View File

@ -15,19 +15,16 @@ package org.eclipse.jetty.server;
import java.io.IOException;
import java.net.Socket;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import javax.net.ssl.SSLEngine;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.StandardByteBufferPool;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.util.annotation.Name;
import org.eclipse.jetty.util.component.AggregateLifeCycle;
import org.eclipse.jetty.util.component.Dumpable;
import org.eclipse.jetty.util.log.Log;
@ -35,49 +32,39 @@ import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.ssl.SslContextFactory;
/**
* Abstract Connector implementation. This abstract implementation of the Connector interface provides:
* <ul>
* <li>AbstractLifeCycle implementation</li>
* <li>Implementations for connector getters and setters</li>
* <li>Buffer management</li>
* <li>Socket configuration</li>
* <li>Base acceptor thread</li>
* <li>Optional reverse proxy headers checking</li>
* </ul>
* <p>Partial implementation of {@link Connector}</p>
*/
public abstract class AbstractConnector extends AggregateLifeCycle implements Connector, Dumpable
{
protected final Logger LOG = Log.getLogger(getClass());
protected final Logger logger = Log.getLogger(getClass());
// Order is important on server side, so we use a LinkedHashMap
private final Map<String, ConnectionFactory> factories = new LinkedHashMap<>();
private final Statistics _stats = new ConnectionStatistics();
private final ConnectionFactory _connectionFactory;
private final Thread[] _acceptors;
private final Server _server;
private final SslContextFactory _sslContextFactory;
private final Executor _executor;
private final ScheduledExecutorService _scheduler;
private final Server _server;
private final ByteBufferPool _byteBufferPool;
private final Thread[] _acceptors;
private volatile String _name;
private volatile int _acceptQueueSize = 128;
private volatile boolean _reuseAddress = true;
private volatile long _idleTimeout = 200000;
private volatile int _soLingerTime = -1;
private volatile ConnectionFactory defaultConnectionFactory;
/* ------------------------------------------------------------ */
/**
* @param server The server this connector will be added to. Must not be null.
* @param connectionFactory ConnectionFactory or null for default
* @param executor An executor for this connector or null to use the servers executor
* @param executor An executor for this connector or null to use the servers executor
* @param scheduler A scheduler for this connector or null to use the servers scheduler
* @param pool A buffer pool for this connector or null to use a default {@link ByteBufferPool}
* @param sslContextFactory the SSL context factory to make this connector SSL enabled, or null
* @param acceptors the number of acceptor threads to use, or 0 for a default value.
*/
public AbstractConnector(
Server server,
ConnectionFactory connectionFactory,
Executor executor,
ScheduledExecutorService scheduler,
ByteBufferPool pool, int acceptors)
Server server,
Executor executor,
ScheduledExecutorService scheduler,
ByteBufferPool pool,
SslContextFactory sslContextFactory,
int acceptors)
{
_server=server;
_executor=executor!=null?executor:_server.getThreadPool();
@ -86,23 +73,22 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
@Override
public Thread newThread(Runnable r)
{
return new Thread(r, "Timer-" + getName());
return new Thread(r, "Scheduler-" + getName());
}
});
_byteBufferPool = pool!=null?pool:new StandardByteBufferPool();
_connectionFactory=connectionFactory!=null?connectionFactory:new ConnectionFactory();
_sslContextFactory = sslContextFactory;
addBean(_server,false);
addBean(_executor,false);
addBean(_scheduler,scheduler==null);
addBean(_byteBufferPool,pool==null);
addBean(_connectionFactory,connectionFactory!=null);
addBean(_sslContextFactory,true);
if (acceptors<=0)
acceptors=Math.max(1,(Runtime.getRuntime().availableProcessors()) / 4);
if (acceptors > 2 * Runtime.getRuntime().availableProcessors())
LOG.warn("Acceptors should be <= 2*availableProcessors: " + this);
logger.warn("Acceptors should be <= 2*availableProcessors: " + this);
_acceptors = new Thread[acceptors];
}
@ -117,13 +103,7 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
{
return _server;
}
@Override
public ConnectionFactory getConnectionFactory()
{
return _connectionFactory;
}
@Override
public Executor getExecutor()
{
@ -136,9 +116,11 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
return _byteBufferPool;
}
/**
* @return Returns the maxIdleTime.
*/
public SslContextFactory getSslContextFactory()
{
return _sslContextFactory;
}
@Override
public long getIdleTimeout()
{
@ -146,52 +128,23 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
}
/**
* Set the maximum Idle time for a connection, which roughly translates to the {@link Socket#setSoTimeout(int)} call, although with NIO implementations
* other mechanisms may be used to implement the timeout. The max idle time is applied:
* <p>Sets the maximum Idle time for a connection, which roughly translates to the {@link Socket#setSoTimeout(int)}
* call, although with NIO implementations other mechanisms may be used to implement the timeout.</p>
* <p>The max idle time is applied:</p>
* <ul>
* <li>When waiting for a new request to be received on a connection</li>
* <li>When reading the headers and content of a request</li>
* <li>When writing the headers and content of a response</li>
* <li>When waiting for a new message to be received on a connection</li>
* <li>When waiting for a new message to be sent on a connection</li>
* </ul>
* Jetty interprets this value as the maximum time between some progress being made on the connection. So if a single byte is read or written, then the
* timeout (if implemented by jetty) is reset. However, in many instances, the reading/writing is delegated to the JVM, and the semantic is more strictly
* enforced as the maximum time a single read/write operation can take. Note, that as Jetty supports writes of memory mapped file buffers, then a write may
* take many 10s of seconds for large content written to a slow device.
* <p/>
* Previously, Jetty supported separate idle timeouts and IO operation timeouts, however the expense of changing the value of soTimeout was significant, so
* these timeouts were merged. With the advent of NIO, it may be possible to again differentiate these values (if there is demand).
* <p>This value is interpreted as the maximum time between some progress being made on the connection.
* So if a single byte is read or written, then the timeout is reset.</p>
*
* @param idleTimeout The idleTimeout to set.
* @param idleTimeout the idle timeout
*/
public void setIdleTimeout(long idleTimeout)
{
_idleTimeout = idleTimeout;
}
/**
* @return Returns the soLingerTime.
*/
public int getSoLingerTime()
{
return _soLingerTime;
}
/**
* @return Returns the acceptQueueSize.
*/
public int getAcceptQueueSize()
{
return _acceptQueueSize;
}
/**
* @param acceptQueueSize The acceptQueueSize to set.
*/
public void setAcceptQueueSize(int acceptQueueSize)
{
_acceptQueueSize = acceptQueueSize;
}
/**
* @return Returns the number of acceptor threads.
*/
@ -201,72 +154,100 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
}
/**
* @param soLingerTime The soLingerTime to set or -1 to disable.
*/
public void setSoLingerTime(int soLingerTime)
{
_soLingerTime = soLingerTime;
}
@Override
protected void doStart() throws Exception
{
super.doStart();
// Start selector thread
synchronized (this)
{
for (int i = 0; i < _acceptors.length; i++)
getExecutor().execute(new Acceptor(i));
}
for (int i = 0; i < _acceptors.length; i++)
getExecutor().execute(new Acceptor(i));
LOG.info("Started {}", this);
logger.info("Started {}", this);
}
@Override
protected void doStop() throws Exception
{
super.doStop();
for (Thread thread : _acceptors)
{
if (thread != null)
thread.interrupt();
}
super.doStop();
logger.info("Stopped {}", this);
}
public void join() throws InterruptedException
{
for (Thread thread : _acceptors)
if (thread != null)
thread.join();
join(0);
}
protected void configure(Socket socket)
public void join(long timeout) throws InterruptedException
{
try
{
socket.setTcpNoDelay(true);
if (_soLingerTime >= 0)
socket.setSoLinger(true, _soLingerTime / 1000);
else
socket.setSoLinger(false, 0);
}
catch (Exception e)
{
LOG.ignore(e);
}
for (Thread thread : _acceptors)
if (thread != null)
thread.join(timeout);
}
protected abstract void accept(int acceptorID) throws IOException, InterruptedException;
/* ------------------------------------------------------------ */
public ConnectionFactory getConnectionFactory(String protocol)
{
synchronized (factories)
{
return factories.get(protocol);
}
}
public ConnectionFactory putConnectionFactory(String protocol, ConnectionFactory factory)
{
synchronized (factories)
{
return factories.put(protocol, factory);
}
}
public ConnectionFactory removeConnectionFactory(String protocol)
{
synchronized (factories)
{
return factories.remove(protocol);
}
}
public Map<String, ConnectionFactory> getConnectionFactories()
{
synchronized (factories)
{
return new LinkedHashMap<>(factories);
}
}
public void clearConnectionFactories()
{
synchronized (factories)
{
factories.clear();
}
}
public ConnectionFactory getDefaultConnectionFactory()
{
return defaultConnectionFactory;
}
public void setDefaultConnectionFactory(ConnectionFactory defaultConnectionFactory)
{
this.defaultConnectionFactory = defaultConnectionFactory;
}
private class Acceptor implements Runnable
{
int _acceptor = 0;
private final int _acceptor;
Acceptor(int id)
private Acceptor(int id)
{
_acceptor = id;
}
@ -275,22 +256,17 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
public void run()
{
Thread current = Thread.currentThread();
String name;
String name = current.getName();
current.setName(name + " Acceptor" + _acceptor + " " + AbstractConnector.this);
synchronized (AbstractConnector.this)
{
if (!isRunning())
return;
_acceptors[_acceptor] = current;
name = _acceptors[_acceptor].getName();
current.setName(name + " Acceptor" + _acceptor + " " + AbstractConnector.this);
}
int old_priority = current.getPriority();
try
{
current.setPriority(old_priority);
while (isRunning() && getTransport() != null)
while (isRunning())
{
try
{
@ -298,17 +274,16 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
}
catch (IOException | InterruptedException e)
{
LOG.ignore(e);
logger.ignore(e);
}
catch (Throwable e)
{
LOG.warn(e);
logger.warn(e);
}
}
}
finally
{
current.setPriority(old_priority);
current.setName(name);
synchronized (AbstractConnector.this)
@ -350,22 +325,6 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
_stats.connectionClosed(duration, requests, requests);
}
/**
* @return True if the the server socket will be opened in SO_REUSEADDR mode.
*/
public boolean getReuseAddress()
{
return _reuseAddress;
}
/**
* @param reuseAddress True if the the server socket will be opened in SO_REUSEADDR mode.
*/
public void setReuseAddress(boolean reuseAddress)
{
_reuseAddress = reuseAddress;
}
public ScheduledExecutorService getScheduler()
{
return _scheduler;

19
jetty-server/src/main/java/org/eclipse/jetty/server/AbstractNetConnector.java → jetty-server/src/main/java/org/eclipse/jetty/server/AbstractNetworkConnector.java
View File

@ -20,14 +20,17 @@ import java.util.concurrent.ScheduledExecutorService;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.util.ssl.SslContextFactory;
public abstract class AbstractNetConnector extends AbstractConnector implements Connector.NetConnector
/**
* <p>Partial implementation of {@link NetworkConnector}.</p>
*/
public abstract class AbstractNetworkConnector extends AbstractConnector implements NetworkConnector
{
private volatile String _host;
private volatile int _port = 0;
public AbstractNetConnector(Server server, ConnectionFactory connectionFactory, Executor executor, ScheduledExecutorService scheduler, ByteBufferPool pool, int acceptors)
public AbstractNetworkConnector(Server server, Executor executor, ScheduledExecutorService scheduler, ByteBufferPool pool, SslContextFactory sslContextFactory, int acceptors)
{
super(server,connectionFactory,executor,scheduler,pool, acceptors);
super(server, executor, scheduler, pool, sslContextFactory, acceptors);
}
public void setHost(String host)
@ -74,14 +77,8 @@ public abstract class AbstractNetConnector extends AbstractConnector implements
@Override
protected void doStop() throws Exception
{
try
{
close();
}
catch (IOException e)
{
LOG.warn(e);
}
close();
super.doStop();
int i = getName().lastIndexOf("/");

84
jetty-server/src/main/java/org/eclipse/jetty/server/ConnectionFactory.java
View File

@ -1,5 +1,5 @@
// ========================================================================
// Copyright (c) 2004-2012 Mort Bay Consulting Pty. Ltd.
// Copyright 2011-2012 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
@ -13,80 +13,22 @@
package org.eclipse.jetty.server;
import java.io.IOException;
import javax.net.ssl.SSLEngine;
import java.nio.channels.SocketChannel;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.util.component.AggregateLifeCycle;
import org.eclipse.jetty.util.ssl.SslContextFactory;
// TODO This is just a place holder for a real factory
public class ConnectionFactory extends AggregateLifeCycle
/**
* <p>Factory for {@link Connection}s.</p>
*/
public interface ConnectionFactory
{
private final boolean _ssl;
private final SslContextFactory _sslContextFactory;
// TODO Make this part of pluggable factory
private final HttpConfiguration _httpConfig;
ConnectionFactory()
{
this(null,false);
}
/* ------------------------------------------------------------ */
/**
* @param sslContextFactory An SslContextFactory to use or null if no ssl is required or to use default {@link SslContextFactory}
* @param ssl If true, then new connections will assumed to be SSL. If false, connections can only become SSL if they upgrade and a SslContextFactory is passed.
/**
* <p>Creates a new {@link Connection} with the given parameters</p>
* @param channel the {@link SocketChannel} associated with the connection
* @param endPoint the {@link EndPoint} associated with the connection
* @param attachment the attachment associated with the connection
* @return a new {@link Connection}
*/
ConnectionFactory(SslContextFactory sslContextFactory, boolean ssl)
{
this(null,sslContextFactory,ssl);
}
ConnectionFactory(HttpConfiguration httpConfig, SslContextFactory sslContextFactory, boolean ssl)
{
_ssl=ssl;
_sslContextFactory=sslContextFactory!=null?sslContextFactory:(ssl?new SslContextFactory(SslContextFactory.DEFAULT_KEYSTORE_PATH):null);
addBean(_sslContextFactory,sslContextFactory==null);
// TODO make this pluggable
_httpConfig = httpConfig!=null?httpConfig:new HttpConfiguration(_sslContextFactory,ssl);
addBean(_httpConfig,httpConfig==null);
}
protected Connection newConnection(Connector connector,EndPoint endp) throws IOException
{
if (_ssl)
{
SSLEngine engine = _sslContextFactory.createSSLEngine(endp.getRemoteAddress());
SslConnection ssl_connection = new SslConnection(connector.getByteBufferPool(), connector.getExecutor(), endp, engine);
Connection http_connection = new HttpConnection(_httpConfig,connector,ssl_connection.getDecryptedEndPoint());
ssl_connection.getDecryptedEndPoint().setConnection(http_connection);
return ssl_connection;
}
return new HttpConnection(_httpConfig,connector,endp);
}
public SslContextFactory getSslContextFactory()
{
return _sslContextFactory;
}
public HttpConfiguration getHttpConfig()
{
return _httpConfig;
}
public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment);
}

26
jetty-server/src/main/java/org/eclipse/jetty/server/ConnectionStatistics.java
View File

@ -28,14 +28,14 @@ class ConnectionStatistics extends AbstractLifeCycle implements Statistics
private final SampleStatistic _messagesOut = new SampleStatistic();
private final SampleStatistic _connectionDurationStats = new SampleStatistic();
/* ------------------------------------------------------------ */
@Override
public int getBytesIn()
{
return -1;
}
/* ------------------------------------------------------------ */
@Override
@ -185,7 +185,7 @@ class ConnectionStatistics extends AbstractLifeCycle implements Statistics
return (start != -1)?(System.currentTimeMillis() - start):0;
}
/* ------------------------------------------------------------ */
@Override
public void doStart()
@ -193,12 +193,12 @@ class ConnectionStatistics extends AbstractLifeCycle implements Statistics
statsReset();
_statsStartedAt.set(System.currentTimeMillis());
}
/* ------------------------------------------------------------ */
@Override
public void doStop()
{
}
/* ------------------------------------------------------------ */
@ -212,7 +212,7 @@ class ConnectionStatistics extends AbstractLifeCycle implements Statistics
_connectionStats.reset();
_connectionDurationStats.reset();
}
/* ------------------------------------------------------------ */
@Override
public void connectionOpened()
@ -223,19 +223,19 @@ class ConnectionStatistics extends AbstractLifeCycle implements Statistics
/* ------------------------------------------------------------ */
@Override
public void connectionUpgraded(long duration, int msgIn, int msgOut)
public void connectionUpgraded(long duration, int messagesIn, int messagesOut)
{
_messagesIn.set(msgIn);
_messagesOut.set(msgOut);
_messagesIn.set(messagesIn);
_messagesOut.set(messagesOut);
}
/* ------------------------------------------------------------ */
@Override
public void connectionClosed(long duration, int msgIn, int msgOut)
public void connectionClosed(long duration, int messagesIn, int messagesOut)
{
_messagesIn.set(msgIn);
_messagesOut.set(msgOut);
_messagesIn.set(messagesIn);
_messagesOut.set(messagesOut);
_connectionStats.decrement();
_connectionDurationStats.set(duration);
}
}
}

223
jetty-server/src/main/java/org/eclipse/jetty/server/Connector.java
View File

@ -13,7 +13,6 @@
package org.eclipse.jetty.server;
import java.io.IOException;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
@ -21,215 +20,183 @@ import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.util.component.LifeCycle;
import org.eclipse.jetty.util.ssl.SslContextFactory;
/** HTTP Connector.
* Implementations of this interface provide connectors for the HTTP protocol.
* A connector receives requests (normally from a socket) and calls the
* handle method of the Handler object. These operations are performed using
* threads from the ThreadPool set on the connector.
*
* When a connector is registered with an instance of Server, then the server
* will set itself as both the ThreadPool and the Handler. Note that a connector
* can be used without a Server if a thread pool and handler are directly provided.
*
/**
* <p>A {@link Connector} accept connections and data from remote peers,
* and allows applications to send data to remote peers, by setting up
* the machinery needed to handle such tasks.</p>
*/
public interface Connector extends LifeCycle
{
/* ------------------------------------------------------------ */
/**
* @return the name of the connector. Defaults to the HostName:port
* @return the name of the connector, defaulting to host:port
*/
String getName();
public String getName();
/* ------------------------------------------------------------ */
Server getServer();
/* ------------------------------------------------------------ */
ConnectionFactory getConnectionFactory();
/* ------------------------------------------------------------ */
Executor getExecutor();
/* ------------------------------------------------------------ */
ScheduledExecutorService getScheduler();
/* ------------------------------------------------------------ */
ByteBufferPool getByteBufferPool();
/* ------------------------------------------------------------ */
/**
* @return Max Idle time for connections in milliseconds
* @return the {@link Server} instance associated with this {@link Connector}
*/
long getIdleTimeout();
public Server getServer();
/**
* @return the {@link Executor} used to submit tasks
*/
public Executor getExecutor();
/**
* @return the {@link ScheduledExecutorService} used to schedule tasks
*/
public ScheduledExecutorService getScheduler();
/**
* @return the {@link ByteBufferPool} to acquire buffers from and release buffers to
*/
public ByteBufferPool getByteBufferPool();
/**
* @return the {@link SslContextFactory} associated with this {@link Connector}
*/
public SslContextFactory getSslContextFactory();
/**
* @return the dle timeout for connections in milliseconds
*/
public long getIdleTimeout();
/* ------------------------------------------------------------ */
/**
* @return the underlying socket, channel, buffer etc. for the connector.
*/
Object getTransport();
public Object getTransport();
/* ------------------------------------------------------------ */
Statistics getStatistics();
/**
* @return the {@link Statistics} associated with this {@link Connector}
*/
public Statistics getStatistics();
interface NetConnector extends Connector, AutoCloseable
/**
* <p>{@link Connector} statistics.</p>
*/
public interface Statistics extends LifeCycle
{
/* ------------------------------------------------------------ */
/**
* Opens the connector
* @throws IOException
* @return true if gathering of statistics is enabled
*/
void open() throws IOException;
public boolean getStatsOn();
/* ------------------------------------------------------------ */
void close() throws IOException;
/* ------------------------------------------------------------ */
/**
* @return The hostname representing the interface to which
* this connector will bind, or null for all interfaces.
* <p>Resets the statistics.</p>
*/
String getHost();
public void statsReset();
/* ------------------------------------------------------------ */
/**
* @return The configured port for the connector or 0 if any available
* port may be used.
*/
int getPort();
/* ------------------------------------------------------------ */
/**
* @return The actual port the connector is listening on or
* -1 if it has not been opened, or -2 if it has been closed.
*/
int getLocalPort();
}
interface Statistics extends LifeCycle
{
/* ------------------------------------------------------------ */
/**
* @return True if statistics collection is turned on.
*/
boolean getStatsOn();
/* ------------------------------------------------------------ */
/** Reset statistics.
*/
void statsReset();
/* ------------------------------------------------------------ */
/**
* @return Get the number of messages received by this connector
* since last call of statsReset(). If setStatsOn(false) then this
* is undefined.
* @return the number of messages received by this connector
* since last call to {@link #statsReset()}.
*/
public int getMessagesIn();
/* ------------------------------------------------------------ */
/**
* @return Get the number of messages sent by this connector
* since last call of statsReset(). If setStatsOn(false) then this
* is undefined.
* @return the number of messages sent by this connector
* since last call to {@link #statsReset()}.
*/
public int getMessagesOut();
/* ------------------------------------------------------------ */
/**
* @return Get the number of bytes received by this connector
* since last call of statsReset(). If setStatsOn(false) then this
* is undefined.
* @return the number of bytes received by this connector
* since last call to {@link #statsReset()}.
*/
public int getBytesIn();
/* ------------------------------------------------------------ */
/**
* @return Get the number of bytes sent by this connector
* since last call of statsReset(). If setStatsOn(false) then this
* is undefined.
* @return the number of bytes sent by this connector
* since last call to {@link #statsReset()}.
*/
public int getBytesOut();
/* ------------------------------------------------------------ */
/**
* @return Returns the connectionsDurationTotal.
* @return the total time connections have been open, in milliseconds,
* since last call to {@link #statsReset()}.
*/
public long getConnectionsDurationTotal();
/* ------------------------------------------------------------ */
/**
* @return Number of connections accepted by the server since
* statsReset() called. Undefined if setStatsOn(false).
* @return the number of connections accepted by the server
* since last call to {@link #statsReset()}.
*/
public int getConnections() ;
/* ------------------------------------------------------------ */
/**
* @return Number of connections currently open that were opened
* since statsReset() called. Undefined if setStatsOn(false).
* @return the number of connections currently open that were opened
* since last call to {@link #statsReset()}.
*/
public int getConnectionsOpen() ;
/* ------------------------------------------------------------ */
/**
* @return Maximum number of connections opened simultaneously
* since statsReset() called. Undefined if setStatsOn(false).
* @return the max number of connections opened simultaneously
* since last call to {@link #statsReset()}.
*/
public int getConnectionsOpenMax() ;
/* ------------------------------------------------------------ */
/**
* @return Maximum duration in milliseconds of an open connection
* since statsReset() called. Undefined if setStatsOn(false).
* @return the max time a connection has been open, in milliseconds,
* since last call to {@link #statsReset()}.
*/
public long getConnectionsDurationMax();
/* ------------------------------------------------------------ */
/**
* @return Mean duration in milliseconds of open connections
* since statsReset() called. Undefined if setStatsOn(false).
* @return the mean time connections have been open, in milliseconds,
* since last call to {@link #statsReset()}.
*/
public double getConnectionsDurationMean() ;
/* ------------------------------------------------------------ */
/**
* @return Standard deviation of duration in milliseconds of
* open connections since statsReset() called. Undefined if
* setStatsOn(false).
* @return the standard deviation of the time connections have been open, in milliseconds,
* since last call to {@link #statsReset()}.
*/
public double getConnectionsDurationStdDev() ;
/* ------------------------------------------------------------ */
/**
* @return Mean number of messages received per connection
* since statsReset() called. Undefined if setStatsOn(false).
* @return the mean number of messages received per connection
* since last call to {@link #statsReset()}.
*/
public double getConnectionsMessagesInMean() ;
/* ------------------------------------------------------------ */
/**
* @return Standard Deviation of number of messages received per connection
* since statsReset() called. Undefined if setStatsOn(false).
* @return the standard deviation of the number of messages received per connection
* since last call to {@link #statsReset()}.
*/
public double getConnectionsMessagesInStdDev() ;
/* ------------------------------------------------------------ */
/**
* @return Maximum number of messages received per connection
* since statsReset() called. Undefined if setStatsOn(false).
* @return the max number of messages received by a connection
* since last call to {@link #statsReset()}.
*/
public int getConnectionsMessagesInMax();
/* ------------------------------------------------------------ */
/**
* @return Timestamp stats were started at.
* @return the number of milliseconds the statistics have been started or reset
*/
public long getStatsOnMs();
void connectionOpened();
/**
* <p>Callback method invoked when a new connection is opened.</p>
*/
public void connectionOpened();
void connectionUpgraded(long duration, int requests, int requests2);
void connectionClosed(long duration, int requests, int requests2);
/**
* <p>Callback method invoked when a connection is upgraded.</p>
*
* @param duration the time the previous connection was opened
* @param messagesIn the number of messages received by the previous connection
* @param messagesOut the number of messages send by the previous connection
*/
public void connectionUpgraded(long duration, int messagesIn, int messagesOut);
/**
* <p>Callback method invoked when a connection is closed.</p>
*
* @param duration the time the connection was opened
* @param messagesIn the number of messages received by the connection
* @param messagesOut the number of messages send by the connection
*/
public void connectionClosed(long duration, int messagesIn, int messagesOut);
}
}

27
jetty-server/src/main/java/org/eclipse/jetty/server/HttpConfiguration.java
View File

@ -2,7 +2,6 @@ package org.eclipse.jetty.server;
import java.io.IOException;
import java.net.InetSocketAddress;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLSession;
import javax.servlet.ServletRequest;
@ -21,10 +20,10 @@ import org.eclipse.jetty.util.ssl.SslContextFactory;
public class HttpConfiguration extends AggregateLifeCycle
{
static final Logger LOG = Log.getLogger(HttpConfiguration.class);
private final SslContextFactory _sslContextFactory;
private final boolean _ssl;
private String _integralScheme = HttpScheme.HTTPS.asString();
private int _integralPort = 0;
private String _confidentialScheme = HttpScheme.HTTPS.asString();
@ -41,7 +40,7 @@ public class HttpConfiguration extends AggregateLifeCycle
private int _requestBufferSize=16*1024;
private int _responseHeaderSize=6*1024;
private int _responseBufferSize=16*1024;
public HttpConfiguration(SslContextFactory sslContextFactory,boolean ssl)
{
_sslContextFactory=sslContextFactory!=null?sslContextFactory:ssl?new SslContextFactory(SslContextFactory.DEFAULT_KEYSTORE_PATH):null;
@ -49,7 +48,7 @@ public class HttpConfiguration extends AggregateLifeCycle
if (_sslContextFactory!=null)
addBean(_sslContextFactory,sslContextFactory==null);
}
public SslContextFactory getSslContextFactory()
{
return _sslContextFactory;
@ -121,7 +120,7 @@ public class HttpConfiguration extends AggregateLifeCycle
* </ul>
*/
public void customize(Request request) throws IOException
{
{
if (isSecure())
{
request.setScheme(HttpScheme.HTTPS.asString());
@ -130,7 +129,7 @@ public class HttpConfiguration extends AggregateLifeCycle
SSLEngine sslEngine=sslConnection.getSSLEngine();
SslCertificates.customize(sslEngine,request);
}
request.setTimeStamp(System.currentTimeMillis());
if (isForwarded())
checkForwardedHeaders(request);
@ -242,13 +241,13 @@ public class HttpConfiguration extends AggregateLifeCycle
/* ------------------------------------------------------------ */
/**
* The request is integral IFF it is secure AND the server port
* matches any configured {@link #getIntegralPort()}.
* matches any configured {@link #getIntegralPort()}.
* This allows separation of listeners providing INTEGRAL versus
* CONFIDENTIAL constraints, such as one SSL listener configured to require
* client certs providing CONFIDENTIAL, whereas another SSL listener not
* requiring client certs providing mere INTEGRAL constraints.
* <p>
* The request is secure if it is SSL or it {@link #isForwarded()} is true
* The request is secure if it is SSL or it {@link #isForwarded()} is true
* and the scheme matches {@link #getIntegralScheme()()}
*/
public boolean isIntegral(Request request)
@ -280,13 +279,13 @@ public class HttpConfiguration extends AggregateLifeCycle
/* ------------------------------------------------------------ */
/**
* The request is confidential IFF it is secure AND the server port
* matches any configured {@link #getConfidentialPort()}.
* matches any configured {@link #getConfidentialPort()}.
* This allows separation of listeners providing INTEGRAL versus
* CONFIDENTIAL constraints, such as one SSL listener configured to require
* client certs providing CONFIDENTIAL, whereas another SSL listener not
* requiring client certs providing mere INTEGRAL constraints.
* <p>
* The request is secure if it is SSL or it {@link #isForwarded()} is true
* The request is secure if it is SSL or it {@link #isForwarded()} is true
* and the scheme matches {@link #getConfidentialScheme()}
*/
public boolean isConfidential(Request request)
@ -510,7 +509,7 @@ public class HttpConfiguration extends AggregateLifeCycle
{
_forwardedSslSessionIdHeader = forwardedSslSessionId;
}
/* ------------------------------------------------------------ */
@Override
@ -521,8 +520,8 @@ public class HttpConfiguration extends AggregateLifeCycle
_sslContextFactory.checkKeyStore();
super.doStart();
SSLEngine sslEngine = _sslContextFactory.newSslEngine();
SSLEngine sslEngine = _sslContextFactory.newSSLEngine();
sslEngine.setUseClientMode(false);

69
jetty-server/src/main/java/org/eclipse/jetty/server/HttpServerConnectionFactory.java Normal file
View File

@ -0,0 +1,69 @@
//========================================================================
//Copyright 2011-2012 Mort Bay Consulting Pty. Ltd.
//------------------------------------------------------------------------
//All rights reserved. This program and the accompanying materials
//are made available under the terms of the Eclipse Public License v1.0
//and Apache License v2.0 which accompanies this distribution.
//The Eclipse Public License is available at
//http://www.eclipse.org/legal/epl-v10.html
//The Apache License v2.0 is available at
//http://www.opensource.org/licenses/apache2.0.php
//You may elect to redistribute this code under either of these licenses.
//========================================================================
package org.eclipse.jetty.server;
import java.nio.channels.SocketChannel;
import javax.net.ssl.SSLEngine;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.util.ssl.SslContextFactory;
public class HttpServerConnectionFactory implements ConnectionFactory
{
private final Connector connector;
private final HttpConfiguration configuration;
public HttpServerConnectionFactory(Connector connector)
{
this(connector, new HttpConfiguration(connector.getSslContextFactory(), connector.getSslContextFactory() != null));
}
public HttpServerConnectionFactory(Connector connector, HttpConfiguration configuration)
{
this.connector = connector;
this.configuration = configuration;
}
public Connector getConnector()
{
return connector;
}
public HttpConfiguration getHttpConfiguration()
{
return configuration;
}
@Override
public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment)
{
SslContextFactory sslContextFactory = connector.getSslContextFactory();
if (sslContextFactory != null)
{
SSLEngine engine = sslContextFactory.newSSLEngine(endPoint.getRemoteAddress());
engine.setUseClientMode(false);
SslConnection sslConnection = new SslConnection(connector.getByteBufferPool(), connector.getExecutor(), endPoint, engine);
Connection httpConnection = new HttpConnection(getHttpConfiguration(), connector, sslConnection.getDecryptedEndPoint());
sslConnection.getDecryptedEndPoint().setConnection(httpConnection);
httpConnection.onOpen();
return sslConnection;
}
else
{
return new HttpConnection(getHttpConfiguration(), getConnector(), endPoint);
}
}
}

27
jetty-server/src/main/java/org/eclipse/jetty/server/HttpServerConnector.java Normal file
View File

@ -0,0 +1,27 @@
package org.eclipse.jetty.server;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.util.annotation.Name;
import org.eclipse.jetty.util.ssl.SslContextFactory;
public class HttpServerConnector extends SelectChannelConnector
{
public HttpServerConnector(Server server)
{
this(server, null);
}
public HttpServerConnector(Server server, SslContextFactory sslContextFactory)
{
this(server, null, null, null, sslContextFactory, 0, 0);
}
public HttpServerConnector(@Name("server") Server server, @Name("executor") Executor executor, @Name("scheduler") ScheduledExecutorService scheduler, @Name("bufferPool") ByteBufferPool pool, @Name("sslContextFactory") SslContextFactory sslContextFactory, @Name("acceptors") int acceptors, @Name("selectors") int selectors)
{
super(server, executor, scheduler, pool, sslContextFactory, acceptors, selectors);
setDefaultConnectionFactory(new HttpServerConnectionFactory(this));
}
}

57
jetty-server/src/main/java/org/eclipse/jetty/server/LocalConnector.java
View File

@ -23,50 +23,34 @@ import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.io.ByteArrayEndPoint;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.util.BufferUtil;
import org.eclipse.jetty.util.StringUtil;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.ssl.SslContextFactory;
public class LocalConnector extends AbstractConnector
{
private static final Logger LOG = Log.getLogger(LocalConnector.class);
private final BlockingQueue<LocalEndPoint> _connects = new LinkedBlockingQueue<>();
public LocalConnector(Server server)
{
this(server,null,null,null,null, -1);
}
public LocalConnector(Server server, boolean ssl)
{
this(server,new ConnectionFactory(null,ssl),null,null,null,0);
manage(getConnectionFactory());
}
public LocalConnector(Server server, HttpConfiguration httpConfig)
{
this(server,new ConnectionFactory(httpConfig,null,false),null,null,null,0);
manage(getConnectionFactory());
this(server,null);
}
public LocalConnector(Server server, SslContextFactory sslContextFactory)
{
this(server,new ConnectionFactory(sslContextFactory,sslContextFactory!=null),null,null,null,0);
manage(getConnectionFactory());
this(server, null, null, null, sslContextFactory, 0);
}
public LocalConnector(Server server, ConnectionFactory connectionFactory, Executor executor, ScheduledExecutorService scheduler, ByteBufferPool pool,
int acceptors)
public LocalConnector(Server server, Executor executor, ScheduledExecutorService scheduler, ByteBufferPool pool,
SslContextFactory sslContextFactory, int acceptors)
{
super(server,connectionFactory,executor,scheduler,pool,acceptors);
super(server,executor,scheduler,pool, sslContextFactory, acceptors);
setIdleTimeout(30000);
setDefaultConnectionFactory(new HttpServerConnectionFactory(this));
}
@Override
public Object getTransport()
{
@ -77,7 +61,7 @@ public class LocalConnector extends AbstractConnector
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
* <p>
* This methods waits until the connection is closed or
* This methods waits until the connection is closed or
* is idle for 1s before returning the responses.
* @param requests the requests
* @return the responses
@ -93,7 +77,7 @@ public class LocalConnector extends AbstractConnector
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
* <p>
* This methods waits until the connection is closed or
* This methods waits until the connection is closed or
* an idle period before returning the responses.
* @param requests the requests
* @param idleFor The time the response stream must be idle for before returning
@ -111,7 +95,7 @@ public class LocalConnector extends AbstractConnector
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
* <p>
* This methods waits until the connection is closed or
* This methods waits until the connection is closed or
* is idle for 1s before returning the responses.
* @param requestsBuffer the requests
* @return the responses
@ -126,7 +110,7 @@ public class LocalConnector extends AbstractConnector
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
* <p>
* This methods waits until the connection is closed or
* This methods waits until the connection is closed or
* an idle period before returning the responses.
* @param requestsBuffer the requests
* @param idleFor The time the response stream must be idle for before returning
@ -136,7 +120,7 @@ public class LocalConnector extends AbstractConnector
*/
public ByteBuffer getResponses(ByteBuffer requestsBuffer,long idleFor,TimeUnit units) throws Exception
{
LOG.debug("getResponses");
logger.debug("getResponses");
LocalEndPoint endp = new LocalEndPoint();
endp.setInput(requestsBuffer);
_connects.add(endp);
@ -161,16 +145,15 @@ public class LocalConnector extends AbstractConnector
@Override
protected void accept(int acceptorID) throws IOException, InterruptedException
{
LOG.debug("accepting {}",acceptorID);
logger.debug("accepting {}", acceptorID);
LocalEndPoint endp = _connects.take();
Connection connection=getConnectionFactory().newConnection(LocalConnector.this,endp);
Connection connection = getDefaultConnectionFactory().newConnection(null, endp, null);
endp.setConnection(connection);
endp.onOpen();
connection.onOpen();
connectionOpened(connection);
}
public class LocalEndPoint extends ByteArrayEndPoint
{
private CountDownLatch _closed = new CountDownLatch(1);
@ -232,7 +215,7 @@ public class LocalConnector extends AbstractConnector
}
catch(Exception e)
{
LOG.warn(e);
logger.warn(e);
}
}
}
@ -254,10 +237,10 @@ public class LocalConnector extends AbstractConnector
}
catch(Exception e)
{
LOG.warn(e);
logger.warn(e);
}
}
}
}
}

56
jetty-server/src/main/java/org/eclipse/jetty/server/NetworkConnector.java Normal file
View File

@ -0,0 +1,56 @@
// ========================================================================
// Copyright (c) 2004-2012 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
package org.eclipse.jetty.server;
import java.io.IOException;
/**
* <p>A {@link Connector} that handles network communication.</p>
*/
public interface NetworkConnector extends Connector, AutoCloseable
{
/**
* <p>Performs the activities needed to open the network communication
* (for example, to start accepting incoming network connections).</p>
*
* @throws IOException if this connector cannot be opened
* @see #close()
*/
void open() throws IOException;
/**
* <p>Performs the activities needed to close the network communication
* (for example, to stop accepting network connections).</p>
* @throws IOException if this connector cannot be closed
*/
void close() throws IOException;
/**
* @return The hostname representing the interface to which
* this connector will bind, or null for all interfaces.
*/
String getHost();
/**
* @return The configured port for the connector or 0 if any available
* port may be used.
*/
int getPort();
/**
* @return The actual port the connector is listening on, or
* -1 if it has not been opened, or -2 if it has been closed.
*/
int getLocalPort();
}

342
jetty-server/src/main/java/org/eclipse/jetty/server/SelectChannelConnector.java
View File

@ -15,7 +15,9 @@ package org.eclipse.jetty.server;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
@ -23,10 +25,9 @@ import java.nio.channels.SocketChannel;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import org.eclipse.jetty.continuation.Continuation;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.SelectChannelEndPoint;
import org.eclipse.jetty.io.SelectorManager;
import org.eclipse.jetty.io.SelectorManager.ManagedSelector;
@ -34,121 +35,139 @@ import org.eclipse.jetty.util.annotation.Name;
import org.eclipse.jetty.util.ssl.SslContextFactory;
/**
* Selecting NIO connector.
* <p>
* This connector uses efficient NIO buffers with a non blocking threading model. Direct NIO buffers
* are used and threads are only allocated to connections with requests. Synchronization is used to
* simulate blocking for the servlet API, and any unflushed content at the end of request handling
* is written asynchronously.
* </p>
* <p>
* This connector is best used when there are a many connections that have idle periods.
* </p>
* <p>
* When used with {@link org.eclipse.jetty.continuation.Continuation}, threadless waits are supported.
* If a filter or servlet returns after calling {@link Continuation#suspend()} or when a
* runtime exception is thrown from a call to {@link Continuation#undispatch()}, Jetty will
* will not send a response to the client. Instead the thread is released and the Continuation is
* placed on the timer queue. If the Continuation timeout expires, or it's
* resume method is called, then the request is again allocated a thread and the request is retried.
* The limitation of this approach is that request content is not available on the retried request,
* thus if possible it should be read after the continuation or saved as a request attribute or as the
* associated object of the Continuation instance.
* </p>
* <p>Implementation of {@link NetworkConnector} based on NIO classes.</p>
*/
public class SelectChannelConnector extends AbstractNetConnector
public class SelectChannelConnector extends AbstractNetworkConnector
{
private final SelectorManager _manager;
protected ServerSocketChannel _acceptChannel;
protected boolean _inheritChannel;
private int _localPort=-1;
/* ------------------------------------------------------------ */
private volatile ServerSocketChannel _acceptChannel;
private volatile boolean _inheritChannel = false;
private volatile int _localPort = -1;
private volatile int _acceptQueueSize = 128;
private volatile boolean _reuseAddress = true;
private volatile int _lingerTime = -1;
public SelectChannelConnector(Server server)
{
this(server,null,null,null,null,0,0);
this(server, null);
}
/* ------------------------------------------------------------ */
public SelectChannelConnector(Server server, boolean ssl)
{
this(server,new ConnectionFactory(null,ssl));
manage(getConnectionFactory());
}
/* ------------------------------------------------------------ */
public SelectChannelConnector(Server server, SslContextFactory sslContextFactory)
{
this(server,new ConnectionFactory(sslContextFactory,sslContextFactory!=null));
manage(getConnectionFactory());
this(server, null, null, null, sslContextFactory, 0, 0);
}
/* ------------------------------------------------------------ */
public SelectChannelConnector(Server server, ConnectionFactory connectionFactory)
{
this(server,connectionFactory,null,null,null,0,0);
}
/* ------------------------------------------------------------ */
/**
* @param server The server this connector will be added to. Must not be null.
* @param executor An executor for this connector or null to use the servers executor
* @param server The server this connector will be added to. Must not be null.
* @param executor An executor for this connector or null to use the servers executor
* @param scheduler A scheduler for this connector or null to use the servers scheduler
* @param pool A buffer pool for this connector or null to use a default {@link ByteBufferPool}
* @param pool A buffer pool for this connector or null to use a default {@link ByteBufferPool}
* @param acceptors the number of acceptor threads to use, or 0 for a default value.
*/
public SelectChannelConnector(
@Name("server") Server server,
@Name("connectionFactory") ConnectionFactory connectionFactory,
@Name("executor") Executor executor,
@Name("scheduler") ScheduledExecutorService scheduler,
@Name("bufferPool") ByteBufferPool pool,
@Name("acceptors") int acceptors,
@Name("selectors") int selectors)
public SelectChannelConnector(
@Name("server") Server server,
@Name("executor") Executor executor,
@Name("scheduler") ScheduledExecutorService scheduler,
@Name("bufferPool") ByteBufferPool pool,
@Name("sslContextFactory") SslContextFactory sslContextFactory,
@Name("acceptors") int acceptors,
@Name("selectors") int selectors)
{
super(server,connectionFactory,executor,scheduler,pool,acceptors);
_manager=new ConnectorSelectorManager(selectors!=0?selectors:Math.max(1,(Runtime.getRuntime().availableProcessors())/4));
addBean(_manager,true);
// TODO yuck
if (getConnectionFactory().getSslContextFactory()!=null)
super(server, executor, scheduler, pool, sslContextFactory, acceptors);
_manager = new ConnectorSelectorManager(selectors > 0 ? selectors : Math.max(1, (Runtime.getRuntime().availableProcessors()) / 4));
addBean(_manager, true);
// TODO: why we need to set the linger time when in SSL mode ?
if (sslContextFactory != null)
setSoLingerTime(30000);
// TODO: we hardcode HTTP, but this is a generic connector that should not hardcode anything
setDefaultConnectionFactory(new HttpServerConnectionFactory(this));
}
/**
* @return whether this connector uses a channel inherited from the JVM.
* @see System#inheritedChannel()
*/
public boolean isInheritChannel()
{
return _inheritChannel;
}
/**
* If true, the connector first tries to inherit from a channel provided by the system.
* If there is no inherited channel available, or if the inherited channel provided not usable,
* then it will fall back upon normal ServerSocketChannel creation.
* <p>
* Use it with xinetd/inetd, to launch an instance of Jetty on demand. The port
* <p>Sets whether this connector uses a channel inherited from the JVM.</p>
* <p>If true, the connector first tries to inherit from a channel provided by the system.
* If there is no inherited channel available, or if the inherited channel is not usable,
* then it will fall back using {@link ServerSocketChannel}.</p>
* <p>Use it with xinetd/inetd, to launch an instance of Jetty on demand. The port
* used to access pages on the Jetty instance is the same as the port used to
* launch Jetty.
*
* launch Jetty.</p>
*
* @param inheritChannel whether this connector uses a channel inherited from the JVM.
*/
public void setInheritChannel(boolean inheritChannel)
{
_inheritChannel = inheritChannel;
}
@Override
public void open() throws IOException
{
if (_acceptChannel == null)
{
ServerSocketChannel serverChannel = null;
if (isInheritChannel())
{
Channel channel = System.inheritedChannel();
if (channel instanceof ServerSocketChannel)
serverChannel = (ServerSocketChannel)channel;
else
logger.warn("Unable to use System.inheritedChannel() [{}]. Trying a new ServerSocketChannel at {}:{}", channel, getHost(), getPort());
}
if (serverChannel == null)
{
serverChannel = ServerSocketChannel.open();
InetSocketAddress bindAddress = getHost() == null ? new InetSocketAddress(getPort()) : new InetSocketAddress(getHost(), getPort());
serverChannel.socket().bind(bindAddress, getAcceptQueueSize());
serverChannel.socket().setReuseAddress(getReuseAddress());
_localPort = serverChannel.socket().getLocalPort();
if (_localPort <= 0)
throw new IOException("Server channel not bound");
addBean(serverChannel);
}
serverChannel.configureBlocking(true);
addBean(serverChannel);
_acceptChannel = serverChannel;
}
}
@Override
public void close() throws IOException
{
ServerSocketChannel serverChannel = _acceptChannel;
if (serverChannel != null)
{
removeBean(serverChannel);
if (serverChannel.isOpen())
serverChannel.close();
}
_acceptChannel = null;
_localPort = -2;
}
@Override
public void accept(int acceptorID) throws IOException
{
ServerSocketChannel server;
synchronized(this)
ServerSocketChannel serverChannel = _acceptChannel;
if (serverChannel != null && serverChannel.isOpen())
{
server = _acceptChannel;
}
if (server!=null && server.isOpen() && _manager.isStarted())
{
SocketChannel channel = server.accept();
SocketChannel channel = serverChannel.accept();
channel.configureBlocking(false);
Socket socket = channel.socket();
configure(socket);
@ -156,19 +175,19 @@ public class SelectChannelConnector extends AbstractNetConnector
}
}
@Override
public void close() throws IOException
protected void configure(Socket socket)
{
synchronized(this)
try
{
if (_acceptChannel != null)
{
removeBean(_acceptChannel);
if (_acceptChannel.isOpen())
_acceptChannel.close();
}
_acceptChannel = null;
_localPort=-2;
socket.setTcpNoDelay(true);
if (_lingerTime >= 0)
socket.setSoLinger(true, _lingerTime / 1000);
else
socket.setSoLinger(false, 0);
}
catch (SocketException e)
{
logger.ignore(e);
}
}
@ -178,7 +197,7 @@ public class SelectChannelConnector extends AbstractNetConnector
}
@Override
public synchronized Object getTransport()
public Object getTransport()
{
return _acceptChannel;
}
@ -186,64 +205,12 @@ public class SelectChannelConnector extends AbstractNetConnector
@Override
public int getLocalPort()
{
synchronized(this)
{
return _localPort;
}
}
@Override
public void open() throws IOException
{
synchronized(this)
{
if (_acceptChannel == null)
{
if (_inheritChannel)
{
Channel channel = System.inheritedChannel();
if ( channel instanceof ServerSocketChannel )
_acceptChannel = (ServerSocketChannel)channel;
else
LOG.warn("Unable to use System.inheritedChannel() [" +channel+ "]. Trying a new ServerSocketChannel at " + getHost() + ":" + getPort());
}
if (_acceptChannel == null)
{
// Create a new server socket
_acceptChannel = ServerSocketChannel.open();
// Bind the server socket to the local host and port
_acceptChannel.socket().setReuseAddress(getReuseAddress());
InetSocketAddress addr = getHost()==null?new InetSocketAddress(getPort()):new InetSocketAddress(getHost(),getPort());
_acceptChannel.socket().bind(addr,getAcceptQueueSize());
_localPort=_acceptChannel.socket().getLocalPort();
if (_localPort<=0)
throw new IOException("Server channel not bound");
addBean(_acceptChannel);
}
_acceptChannel.configureBlocking(true);
addBean(_acceptChannel);
}
}
}
/*
* @see org.eclipse.jetty.server.server.AbstractConnector#doStart()
*/
@Override
protected void doStart() throws Exception
{
super.doStart();
return _localPort;
}
protected SelectChannelEndPoint newEndPoint(SocketChannel channel, ManagedSelector selectSet, SelectionKey key) throws IOException
{
return new SelectChannelEndPoint(channel,selectSet,key, getScheduler(), getIdleTimeout());
return new SelectChannelEndPoint(channel, selectSet, key, getScheduler(), getIdleTimeout());
}
protected void endPointClosed(EndPoint endpoint)
@ -251,12 +218,68 @@ public class SelectChannelConnector extends AbstractNetConnector
connectionClosed(endpoint.getConnection());
}
/* ------------------------------------------------------------ */
protected Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment)
{
return getDefaultConnectionFactory().newConnection(channel, endPoint, attachment);
}
/**
* @return the linger time
* @see Socket#getSoLinger()
*/
public int getLingerTime()
{
return _lingerTime;
}
/**
* @param lingerTime the linger time. Use -1 to disable.
* @see Socket#setSoLinger(boolean, int)
*/
public void setSoLingerTime(int lingerTime)
{
_lingerTime = lingerTime;
}
/**
* @return the accept queue size
*/
public int getAcceptQueueSize()
{
return _acceptQueueSize;
}
/**
* @param acceptQueueSize the accept queue size (also known as accept backlog)
*/
public void setAcceptQueueSize(int acceptQueueSize)
{
_acceptQueueSize = acceptQueueSize;
}
/**
* @return whether the server socket reuses addresses
* @see ServerSocket#getReuseAddress()
*/
public boolean getReuseAddress()
{
return _reuseAddress;
}
/**
* @param reuseAddress whether the server socket reuses addresses
* @see ServerSocket#setReuseAddress(boolean)
*/
public void setReuseAddress(boolean reuseAddress)
{
_reuseAddress = reuseAddress;
}
private final class ConnectorSelectorManager extends SelectorManager
{
private ConnectorSelectorManager(int selectSets)
private ConnectorSelectorManager(int selectors)
{
super(selectSets);
super(selectors);
}
@Override
@ -266,18 +289,17 @@ public class SelectChannelConnector extends AbstractNetConnector
}
@Override
protected void endPointClosed(EndPoint endpoint)
public void connectionOpened(Connection connection)
{
SelectChannelConnector.this.connectionClosed(endpoint.getConnection());
super.endPointClosed(endpoint);
super.connectionOpened(connection);
SelectChannelConnector.this.connectionOpened(connection);
}
@Override
protected void endPointOpened(EndPoint endpoint)
public void connectionClosed(Connection connection)
{
// TODO handle max connections and low resources
super.endPointOpened(endpoint);
SelectChannelConnector.this.connectionOpened(endpoint.getConnection());
super.connectionClosed(connection);
SelectChannelConnector.this.connectionClosed(connection);
}
@Override
@ -290,13 +312,13 @@ public class SelectChannelConnector extends AbstractNetConnector
@Override
protected SelectChannelEndPoint newEndPoint(SocketChannel channel, ManagedSelector selectSet, SelectionKey selectionKey) throws IOException
{
return SelectChannelConnector.this.newEndPoint(channel,selectSet, selectionKey);
return SelectChannelConnector.this.newEndPoint(channel, selectSet, selectionKey);
}
@Override
public Connection newConnection(SocketChannel channel, EndPoint endpoint, Object attachment) throws IOException
{
return getConnectionFactory().newConnection(SelectChannelConnector.this,endpoint);
return SelectChannelConnector.this.newConnection(channel, endpoint, attachment);
}
}
}

20
jetty-server/src/main/java/org/eclipse/jetty/server/Server.java
View File

@ -4,7 +4,7 @@
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
@ -16,14 +16,12 @@ package org.eclipse.jetty.server;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.http.HttpGenerator;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.server.Connector.NetConnector;
import org.eclipse.jetty.server.handler.HandlerWrapper;
import org.eclipse.jetty.util.Attributes;
import org.eclipse.jetty.util.AttributesMap;
@ -117,7 +115,7 @@ public class Server extends HandlerWrapper implements Attributes
addBean(_threadPool,pool==null);
setServer(this);
}
/* ------------------------------------------------------------ */
public static String getVersion()
@ -148,15 +146,15 @@ public class Server extends HandlerWrapper implements Attributes
{
//and we weren't stopping before
if (!_stopAtShutdown)
{
{
//only register to stop if we're already started (otherwise we'll do it in doStart())
if (isStarted())
if (isStarted())
ShutdownThread.register(this);
}
}
else
ShutdownThread.deregister(this);
_stopAtShutdown=stop;
}
@ -302,8 +300,8 @@ public class Server extends HandlerWrapper implements Attributes
for (int i=_connectors.length;i-->0;)
{
LOG.info("Graceful shutdown {}",_connectors[i]);
if (_connectors[i] instanceof NetConnector)
((NetConnector)_connectors[i]).close();
if (_connectors[i] instanceof NetworkConnector)
((NetworkConnector)_connectors[i]).close();
}
}
@ -457,7 +455,7 @@ public class Server extends HandlerWrapper implements Attributes
}
/* ------------------------------------------------------------ */
/**
/**
*/
@Deprecated
public int getMaxCookieVersion()
@ -466,7 +464,7 @@ public class Server extends HandlerWrapper implements Attributes
}
/* ------------------------------------------------------------ */
/**
/**
*/
@Deprecated
public void setMaxCookieVersion(int maxCookieVersion)

4
jetty-server/src/main/java/org/eclipse/jetty/server/ssl/SslSelectChannelConnector.java
View File

@ -24,10 +24,10 @@ import org.eclipse.jetty.util.ssl.SslContextFactory;
* @deprecated use SelectChannelConnector with {@link SslContextFactory}
* @org.apache.xbean.XBean element="sslConnector" description="Creates an NIO ssl connector"
*/
public class SslSelectChannelConnector extends SelectChannelConnector
public class SslSelectChannelConnector extends SelectChannelConnector
{
public SslSelectChannelConnector(Server server)
{
super(server,true);
super(server,new SslContextFactory());
}
}

14
jetty-server/src/test/java/org/eclipse/jetty/server/CheckReverseProxyHeadersTest.java
View File

@ -13,12 +13,7 @@
package org.eclipse.jetty.server;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -26,6 +21,10 @@ import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
*
*/
@ -94,9 +93,10 @@ public class CheckReverseProxyHeadersTest
{
Server server = new Server();
LocalConnector connector = new LocalConnector(server);
// Activate reverse proxy headers checking
connector.getConnectionFactory().getHttpConfig().setForwarded(true);
HttpConfiguration httpConfiguration = new HttpConfiguration(null, false);
httpConfiguration.setForwarded(true);
connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(connector, httpConfiguration));
server.setConnectors(new Connector[] {connector});
ValidationHandler validationHandler = new ValidationHandler(requestValidator);

39
jetty-server/src/test/java/org/eclipse/jetty/server/HttpConnectionTest.java
View File

@ -19,16 +19,9 @@
*/
package org.eclipse.jetty.server;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -45,6 +38,12 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
*
*/
@ -61,8 +60,10 @@ public class HttpConnectionTest
server = new Server();
connector = new LocalConnector(server);
server.addConnector(connector);
connector.getConnectionFactory().getHttpConfig().setRequestHeaderSize(1024);
connector.getConnectionFactory().getHttpConfig().setResponseHeaderSize(1024);
HttpConfiguration httpConfiguration = new HttpConfiguration(null, false);
httpConfiguration.setRequestHeaderSize(1024);
httpConfiguration.setResponseHeaderSize(1024);
connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(connector, httpConfiguration));
server.setHandler(new DumpHandler());
server.start();
}
@ -135,7 +136,7 @@ public class HttpConnectionTest
offset = checkContains(response,offset,"HTTP/1.1 200");
checkContains(response,offset,"/R1");
}
@Test
public void testHead() throws Exception
{
@ -143,15 +144,15 @@ public class HttpConnectionTest
"Host: localhost\015\012"+
"Connection: close\015\012"+
"\015\012");
String responseHEAD=connector.getResponses("HEAD /R1 HTTP/1.1\015\012"+
"Host: localhost\015\012"+
"Connection: close\015\012"+
"\015\012");
assertThat(responsePOST,startsWith(responseHEAD.substring(0,responseHEAD.length()-2)));
assertThat(responsePOST.length(),greaterThan(responseHEAD.length()));
responsePOST=connector.getResponses("POST /R1 HTTP/1.1\015\012"+
"Host: localhost\015\012"+
"Connection: close\015\012"+
@ -413,7 +414,7 @@ public class HttpConnectionTest
{
String response = null;
int offset = 0;
StringBuilder request = new StringBuilder();
request.append("GET / HTTP/1.1\n");
request.append("Host: localhost\n");
@ -422,7 +423,7 @@ public class HttpConnectionTest
request.append(String.format("X-Header-%04d: %08x\n", i, i));
}
request.append("\015\012");
response = connector.getResponses(request.toString());
checkContains(response, offset, "HTTP/1.1 413");
}
@ -434,8 +435,8 @@ public class HttpConnectionTest
for (int i=0;i<500;i++)
str+="xxxxxxxxxxxx";
final String longstr = str;
String response = null;
String response = null;
server.stop();
server.setHandler(new DumpHandler()
{
@ -488,8 +489,8 @@ public class HttpConnectionTest
for (int i=0;i<500;i++)
str+="xxxxxxxxxxxx";
final String longstr = str;
String response = null;
String response = null;
server.stop();
server.setHandler(new DumpHandler()
{

29
jetty-server/src/test/java/org/eclipse/jetty/server/HttpServerTestFixture.java
View File

@ -19,7 +19,6 @@ import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.net.Socket;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSession;
import javax.servlet.ServletException;
@ -39,9 +38,9 @@ public class HttpServerTestFixture
protected static final long PAUSE=10L;
protected static final int LOOPS=Stress.isEnabled()?250:50;
protected static final String HOST="localhost";
protected static Server _server;
protected static Connector.NetConnector _connector;
protected static NetworkConnector _connector;
protected String _scheme="http";
protected Socket newSocket(String host,int port) throws Exception
@ -52,14 +51,14 @@ public class HttpServerTestFixture
socket.setSoLinger(false,0);
return socket;
}
@BeforeClass
public static void before()
{
_server = new Server();
}
protected static void startServer(Connector.NetConnector connector) throws Exception
protected static void startServer(NetworkConnector connector) throws Exception
{
_connector = connector;
_server.addConnector(_connector);
@ -81,20 +80,20 @@ public class HttpServerTestFixture
current.setHandler(handler);
current.start();
}
protected static class EchoHandler extends AbstractHandler
{
boolean musthavecontent=true;
public EchoHandler()
{}
public EchoHandler(boolean content)
{
musthavecontent=false;
}
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
{
@ -111,7 +110,7 @@ public class HttpServerTestFixture
int count=0;
BufferedReader reader=request.getReader();
if (request.getContentLength()!=0)
{
String line=reader.readLine();
@ -123,7 +122,7 @@ public class HttpServerTestFixture
line=reader.readLine();
}
}
if (count==0)
{
if (musthavecontent)
@ -131,7 +130,7 @@ public class HttpServerTestFixture
writer.println("No content");
}
// just to be difficult
reader.close();
writer.close();
@ -171,7 +170,7 @@ public class HttpServerTestFixture
String data = "\u0a870123456789A\u0a87CDEFGHIJKLMNOPQRSTUVWXYZ\u0250bcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
while (data.length()<block)
data+=data;
String chunk = (input+data).substring(0,block);
response.setContentType("text/plain");
if (encoding==null)
@ -206,7 +205,7 @@ public class HttpServerTestFixture
}
}
public final static HostnameVerifier __hostnameverifier = new HostnameVerifier()
{
public boolean verify(String hostname, SSLSession session)

44
jetty-server/src/test/java/org/eclipse/jetty/server/RequestTest.java
View File

@ -13,14 +13,6 @@
package org.eclipse.jetty.server;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
@ -32,7 +24,6 @@ import java.util.Arrays;
import java.util.Enumeration;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
@ -52,6 +43,14 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class RequestTest
{
private static final Logger LOG = Log.getLogger(RequestTest.class);
@ -64,11 +63,14 @@ public class RequestTest
{
_server = new Server();
_connector = new LocalConnector(_server);
_connector.getConnectionFactory().getHttpConfig().setRequestHeaderSize(512);
_connector.getConnectionFactory().getHttpConfig().setRequestBufferSize(1024);
_connector.getConnectionFactory().getHttpConfig().setResponseHeaderSize(512);
_connector.getConnectionFactory().getHttpConfig().setResponseBufferSize(2048);
_connector.getConnectionFactory().getHttpConfig().setForwarded(true);
HttpConfiguration httpConfiguration = new HttpConfiguration(null, false);
httpConfiguration.setRequestHeaderSize(512);
httpConfiguration.setRequestBufferSize(1024);
httpConfiguration.setResponseHeaderSize(512);
httpConfiguration.setResponseBufferSize(2048);
httpConfiguration.setForwarded(true);
HttpServerConnectionFactory defaultConnectionFactory = new HttpServerConnectionFactory(_connector, httpConfiguration);
_connector.setDefaultConnectionFactory(defaultConnectionFactory);
_server.addConnector(_connector);
_handler = new RequestHandler();
_server.setHandler(_handler);
@ -125,7 +127,7 @@ public class RequestTest
assertTrue(responses.startsWith("HTTP/1.1 200"));
}
@Test
public void testMultiPart() throws Exception
{
@ -149,7 +151,7 @@ public class RequestTest
}
}
};
String multipart = "--AaB03x\r\n"+
"content-disposition: form-data; name=\"field1\"\r\n"+
"\r\n"+
@ -160,7 +162,7 @@ public class RequestTest
"\r\n"+
"000000000000000000000000000000000000000000000000000\r\n"+
"--AaB03x--\r\n";
String request="GET / HTTP/1.1\r\n"+
"Host: whatever\r\n"+
"Content-Type: multipart/form-data; boundary=\"AaB03x\"\r\n"+
@ -275,7 +277,7 @@ public class RequestTest
@Test
public void testHostPort() throws Exception
{
{
final ArrayList<String> results = new ArrayList<String>();
_handler._checker = new RequestTester()
{
@ -326,8 +328,8 @@ public class RequestTest
"x-forwarded-for: remote\n"+
"x-forwarded-proto: https\n"+
"\n",10,TimeUnit.SECONDS);
int i=0;
assertEquals("0.0.0.0",results.get(i++));
assertEquals("myhost",results.get(i++));
@ -920,7 +922,7 @@ public class RequestTest
{
((Request)request).setHandled(true);
if (request.getContentLength()>0
if (request.getContentLength()>0
&& !MimeTypes.Type.FORM_ENCODED.asString().equals(request.getContentType())
&& !request.getContentType().startsWith("multipart/form-data"))
_content=IO.toString(request.getInputStream());

17
jetty-server/src/test/java/org/eclipse/jetty/server/ResponseTest.java
View File

@ -13,11 +13,6 @@
package org.eclipse.jetty.server;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
@ -29,7 +24,6 @@ import java.util.Locale;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
@ -52,6 +46,11 @@ import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
*
*/
@ -89,7 +88,7 @@ public class ResponseTest
super.onOpen();
fillInterested();
}
@Override
public void onFillable()
{
@ -160,7 +159,7 @@ public class ResponseTest
protected void commitResponse(ResponseInfo info, ByteBuffer content) throws IOException
{
}
@Override
public Connector getConnector()
{
@ -600,7 +599,7 @@ public class ResponseTest
});
server.start();
Socket socket = new Socket("localhost",((Connector.NetConnector)server.getConnectors()[0]).getLocalPort());
Socket socket = new Socket("localhost",((NetworkConnector)server.getConnectors()[0]).getLocalPort());
socket.getOutputStream().write("HEAD / HTTP/1.1\r\nHost: localhost\r\n\r\n".getBytes());
socket.getOutputStream().write("GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n".getBytes());
socket.getOutputStream().flush();

9
jetty-server/src/test/java/org/eclipse/jetty/server/SelectChannelStatisticsTest.java
View File

@ -13,9 +13,6 @@
package org.eclipse.jetty.server;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@ -23,7 +20,6 @@ import java.io.PrintWriter;
import java.net.Socket;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -40,12 +36,15 @@ import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class SelectChannelStatisticsTest
{
private static final Logger LOG = Log.getLogger(SelectChannelStatisticsTest.class);
private static Server _server;
private static AbstractNetConnector _connector;
private static AbstractNetworkConnector _connector;
private static CyclicBarrier _connect;
private static CountDownLatch _closed;

19
jetty-server/src/test/java/org/eclipse/jetty/server/SlowClientWithPipelinedRequestTest.java
View File

@ -12,16 +12,14 @@ package org.eclipse.jetty.server;
//You may elect to redistribute this code under either of these licenses.
//========================================================================
import static org.hamcrest.Matchers.lessThan;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@ -34,6 +32,8 @@ import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import static org.hamcrest.Matchers.lessThan;
public class SlowClientWithPipelinedRequestTest
{
private final AtomicInteger handles = new AtomicInteger();
@ -43,23 +43,24 @@ public class SlowClientWithPipelinedRequestTest
public void startServer(Handler handler) throws Exception
{
server = new Server();
connector = new SelectChannelConnector(server,new ConnectionFactory()
connector = new SelectChannelConnector(server);
connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(connector)
{
@Override
protected Connection newConnection(Connector connector,EndPoint endpoint)
public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment)
{
return new HttpConnection(getHttpConfig(),connector,endpoint)
return new HttpConnection(getHttpConfiguration(), getConnector(), endPoint)
{
@Override
public synchronized void onFillable()
public void onFillable()
{
handles.incrementAndGet();
super.onFillable();
}
};
}
},null,null,null,0,0);
});
server.addConnector(connector);
connector.setPort(0);
server.setHandler(handler);

56
jetty-server/src/test/java/org/eclipse/jetty/server/handler/IPAccessHandlerTest.java
View File

@ -4,18 +4,15 @@
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
package org.eclipse.jetty.server.handler;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.IOException;
@ -28,13 +25,13 @@ import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.http.HttpStatus;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
@ -45,19 +42,22 @@ import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@RunWith(Parameterized.class)
public class IPAccessHandlerTest
{
private static Server _server;
private static Connector.NetConnector _connector;
private static NetworkConnector _connector;
private static IPAccessHandler _handler;
private String _white;
private String _black;
private String _host;
private String _uri;
private String _code;
@BeforeClass
public static void setUp()
throws Exception
@ -78,7 +78,7 @@ public class IPAccessHandlerTest
_server.setHandler(_handler);
_server.start();
}
/* ------------------------------------------------------------ */
@AfterClass
public static void tearDown()
@ -86,7 +86,7 @@ public class IPAccessHandlerTest
{
_server.stop();
}
/* ------------------------------------------------------------ */
public IPAccessHandlerTest(String white, String black, String host, String uri, String code)
{
@ -96,7 +96,7 @@ public class IPAccessHandlerTest
_uri = uri;
_code = code;
}
/* ------------------------------------------------------------ */
@Test
public void testHandler()
@ -104,7 +104,7 @@ public class IPAccessHandlerTest
{
_handler.setWhite(_white.split(";",-1));
_handler.setBlack(_black.split(";",-1));
String request = "GET " + _uri + " HTTP/1.1\n" + "Host: "+ _host + "\n\n";
Socket socket = new Socket("127.0.0.1", _connector.getLocalPort());
socket.setSoTimeout(5000);
@ -231,7 +231,7 @@ public class IPAccessHandlerTest
return builder.toString();
}
}
/* ------------------------------------------------------------ */
@Parameters
public static Collection<Object[]> data() {
@ -239,20 +239,20 @@ public class IPAccessHandlerTest
// Empty lists
{"", "", "127.0.0.1", "/", "200"},
{"", "", "127.0.0.1", "/dump/info", "200"},
// White list
// White list
{"127.0.0.1", "", "127.0.0.1", "/", "200"},
{"127.0.0.1", "", "127.0.0.1", "/dispatch", "200"},
{"127.0.0.1", "", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/", "", "127.0.0.1", "/", "200"},
{"127.0.0.1|/", "", "127.0.0.1", "/dispatch", "403"},
{"127.0.0.1|/", "", "127.0.0.1", "/dump/info", "403"},
{"127.0.0.1|/*", "", "127.0.0.1", "/", "200"},
{"127.0.0.1|/*", "", "127.0.0.1", "/dispatch", "200"},
{"127.0.0.1|/*", "", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/dump/*", "", "127.0.0.1", "/", "403"},
{"127.0.0.1|/dump/*", "", "127.0.0.1", "/dispatch", "403"},
{"127.0.0.1|/dump/*", "", "127.0.0.1", "/dump/info", "200"},
@ -268,7 +268,7 @@ public class IPAccessHandlerTest
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "", "127.0.0.1", "/dump/test", "200"},
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "", "127.0.0.1", "/dump/fail", "403"},
{"127.0.0.0-2|", "", "127.0.0.1", "/", "200"},
{"127.0.0.0-2|", "", "127.0.0.1", "/dump/info", "200"},
@ -290,20 +290,20 @@ public class IPAccessHandlerTest
{"127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "", "127.0.0.1", "/dump/test", "200"},
{"127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "", "127.0.0.1", "/dump/fail", "403"},
// Black list
{"", "127.0.0.1", "127.0.0.1", "/", "403"},
{"", "127.0.0.1", "127.0.0.1", "/dispatch", "403"},
{"", "127.0.0.1", "127.0.0.1", "/dump/info", "403"},
{"", "127.0.0.1|/", "127.0.0.1", "/", "403"},
{"", "127.0.0.1|/", "127.0.0.1", "/dispatch", "200"},
{"", "127.0.0.1|/", "127.0.0.1", "/dump/info", "200"},
{"", "127.0.0.1|/*", "127.0.0.1", "/", "403"},
{"", "127.0.0.1|/*", "127.0.0.1", "/dispatch", "403"},
{"", "127.0.0.1|/*", "127.0.0.1", "/dump/info", "403"},
{"", "127.0.0.1|/dump/*", "127.0.0.1", "/", "200"},
{"", "127.0.0.1|/dump/*", "127.0.0.1", "/dispatch", "200"},
{"", "127.0.0.1|/dump/*", "127.0.0.1", "/dump/info", "403"},
@ -319,7 +319,7 @@ public class IPAccessHandlerTest
{"", "127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1", "/dump/info", "403"},
{"", "127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1", "/dump/test", "403"},
{"", "127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1", "/dump/fail", "200"},
{"", "127.0.0.0-2|", "127.0.0.1", "/", "403"},
{"", "127.0.0.0-2|", "127.0.0.1", "/dump/info", "403"},
@ -341,7 +341,7 @@ public class IPAccessHandlerTest
{"", "127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "127.0.0.1", "/dump/info", "403"},
{"", "127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "127.0.0.1", "/dump/test", "403"},
{"", "127.0.0.0-2|/dump/info;127.0.0.0-2|/dump/test", "127.0.0.1", "/dump/fail", "200"},
// Both lists
{"127.0.0.1|/dump", "127.0.0.1|/dump/fail", "127.0.0.1", "/dump", "200"},
{"127.0.0.1|/dump", "127.0.0.1|/dump/fail", "127.0.0.1", "/dump/info", "403"},
@ -355,7 +355,7 @@ public class IPAccessHandlerTest
{"127.0.0.1|/dump/*", "127.0.0.1|/dump/test;127.0.0.1|/dump/fail", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/dump/*", "127.0.0.1|/dump/test;127.0.0.1|/dump/fail", "127.0.0.1", "/dump/test", "403"},
{"127.0.0.1|/dump/*", "127.0.0.1|/dump/test;127.0.0.1|/dump/fail", "127.0.0.1", "/dump/fail", "403"},
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1|/dump/test", "127.0.0.1", "/dump", "403"},
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1|/dump/test", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/dump/info;127.0.0.1|/dump/test", "127.0.0.1|/dump/test", "127.0.0.1", "/dump/test", "403"},
@ -381,7 +381,7 @@ public class IPAccessHandlerTest
{"127.0.0.1|/dump/info;127.0.0.2|/dump/test", "", "127.0.0.1", "/dump/info", "200"},
{"127.0.0.1|/dump/info;127.0.0.2|/dump/test", "", "127.0.0.1", "/dump/test", "403"},
{"127.0.0.1|/dump/info;127.0.0.2|/dump/test", "", "127.0.0.1", "/dump/fail", "403"},
{"172.0.0.0-255", "", "127.0.0.1", "/", "403"},
{"172.0.0.0-255", "", "127.0.0.1", "/dump/info", "403"},

15
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SSLCloseTest.java
View File

@ -21,7 +21,6 @@ import java.io.OutputStream;
import java.net.Socket;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
@ -30,13 +29,13 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import junit.framework.TestCase;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.util.ssl.SslContextFactory;
/**
* HttpServer Tester.
@ -72,15 +71,15 @@ public class SSLCloseTest extends TestCase
*/
public void testClose() throws Exception
{
Server server=new Server();
SelectChannelConnector connector=new SelectChannelConnector(server,true);
String keystore = System.getProperty("user.dir")+File.separator+"src"+File.separator+"test"+File.separator+"resources"+File.separator+"keystore";
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystore);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
Server server=new Server();
SelectChannelConnector connector=new SelectChannelConnector(server, sslContextFactory);
connector.setPort(0);
connector.getConnectionFactory().getSslContextFactory().setKeyStorePath(keystore);
connector.getConnectionFactory().getSslContextFactory().setKeyStorePassword("storepwd");
connector.getConnectionFactory().getSslContextFactory().setKeyManagerPassword("keypwd");
server.setConnectors(new Connector[]
{ connector });

47
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SSLEngineTest.java
View File

@ -18,11 +18,6 @@
package org.eclipse.jetty.server.ssl;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
@ -33,7 +28,6 @@ import java.net.HttpURLConnection;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.URL;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
@ -43,7 +37,8 @@ import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpServerConnectionFactory;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
@ -56,6 +51,11 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
/**
*
*/
@ -85,23 +85,25 @@ public class SSLEngineTest
private Server server;
private SelectChannelConnector connector;
@Before
public void startServer() throws Exception
{
server=new Server();
connector=new SelectChannelConnector(server,true);
String keystore = MavenTestingUtils.getTestResourceFile("keystore").getAbsolutePath();
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystore);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
server=new Server();
connector=new SelectChannelConnector(server, sslContextFactory);
connector.setPort(0);
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keystore);
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
connector.getConnectionFactory().getHttpConfig().setRequestBufferSize(512);
connector.getConnectionFactory().getHttpConfig().setRequestHeaderSize(512);
HttpConfiguration httpConfiguration = new HttpConfiguration(sslContextFactory, true);
httpConfiguration.setRequestBufferSize(512);
httpConfiguration.setRequestHeaderSize(512);
connector.setDefaultConnectionFactory(new HttpServerConnectionFactory(connector, httpConfiguration));
server.setConnectors(new Connector[]{connector });
server.addConnector(connector);
}
@After
@ -111,14 +113,13 @@ public class SSLEngineTest
server.join();
}
@Test
public void testHelloWorld() throws Exception
{
server.setHandler(new HelloWorldHandler());
server.start();
server.dumpStdErr();
SSLContext ctx=SSLContext.getInstance("TLS");
ctx.init(null,SslContextFactory.TRUST_ALL_CERTS,new java.security.SecureRandom());
@ -141,13 +142,13 @@ public class SSLEngineTest
assertThat(response,Matchers.containsString("200 OK"));
assertThat(response,Matchers.containsString(HELLO_WORLD));
}
@Test
public void testBigResponse() throws Exception
{
server.setHandler(new HelloWorldHandler());
server.start();
SSLContext ctx=SSLContext.getInstance("TLS");
ctx.init(null,SslContextFactory.TRUST_ALL_CERTS,new java.security.SecureRandom());
@ -175,7 +176,7 @@ public class SSLEngineTest
{
server.setHandler(new HelloWorldHandler());
server.start();
final int loops=20;
final int numConns=20;
@ -384,5 +385,5 @@ public class SSLEngineTest
response.flushBuffer();
}
}
}

26
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SSLSelectChannelConnectorLoadTest.java
View File

@ -26,7 +26,6 @@ import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManagerFactory;
@ -35,6 +34,7 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.util.ssl.SslContextFactory;
@ -45,30 +45,30 @@ import org.junit.Test;
public class SSLSelectChannelConnectorLoadTest
{
private static Server server;
private static SslSelectChannelConnector connector;
private static SelectChannelConnector connector;
private static SSLContext sslContext;
@BeforeClass
public static void startServer() throws Exception
{
server = new Server();
connector = new SslSelectChannelConnector(server);
server.addConnector(connector);
String keystorePath = System.getProperty("basedir", ".") + "/src/test/resources/keystore";
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keystorePath);
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
cf.setTrustStore(keystorePath);
cf.setTrustStorePassword("storepwd");
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystorePath);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
sslContextFactory.setTrustStore(keystorePath);
sslContextFactory.setTrustStorePassword("storepwd");
server = new Server();
connector = new SelectChannelConnector(server, sslContextFactory);
server.addConnector(connector);
server.setHandler(new EmptyHandler());
server.start();
KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
keystore.load(new FileInputStream(connector.getConnectionFactory().getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
keystore.load(new FileInputStream(keystorePath), "storepwd".toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keystore);
sslContext = SSLContext.getInstance("SSL");

46
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SelectChannelServerSslTest.java
View File

@ -12,14 +12,11 @@
// ========================================================================
package org.eclipse.jetty.server.ssl;
import static org.junit.Assert.assertEquals;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.security.KeyStore;
import java.util.Arrays;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
@ -31,6 +28,8 @@ import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
/**
* HttpServer Tester.
*/
@ -40,48 +39,47 @@ public class SelectChannelServerSslTest extends HttpServerTestBase
{
_scheme="https";
}
@Override
protected Socket newSocket(String host, int port) throws Exception
{
return __sslContext.getSocketFactory().createSocket(host,port);
}
@BeforeClass
public static void init() throws Exception
{
SelectChannelConnector connector = new SelectChannelConnector(_server,true);
{
String keystorePath = System.getProperty("basedir",".") + "/src/test/resources/keystore";
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keystorePath);
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
cf.setTrustStore(keystorePath);
cf.setTrustStorePassword("storepwd");
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystorePath);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
sslContextFactory.setTrustStore(keystorePath);
sslContextFactory.setTrustStorePassword("storepwd");
SelectChannelConnector connector = new SelectChannelConnector(_server, sslContextFactory);
startServer(connector);
KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
keystore.load(new FileInputStream(connector.getConnectionFactory().getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
keystore.load(new FileInputStream(connector.getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keystore);
__sslContext = SSLContext.getInstance("TLS");
__sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
try
{
HttpsURLConnection.setDefaultHostnameVerifier(__hostnameverifier);
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, SslContextFactory.TRUST_ALL_CERTS, new java.security.SecureRandom());
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, SslContextFactory.TRUST_ALL_CERTS, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
}
catch(Exception e)
{
e.printStackTrace();
throw new RuntimeException(e);
}
}
}
}
@Test
public void testRequest2FixedFragments() throws Exception
@ -104,7 +102,7 @@ public class SelectChannelServerSslTest extends HttpServerTestBase
// Write out the fragments
for (int j=0; j<points.length; ++j)
{
int point=points[j];
int point=points[j];
os.write(bytes,last,point-last);
last=point;
os.flush();
@ -116,7 +114,7 @@ public class SelectChannelServerSslTest extends HttpServerTestBase
os.write(bytes,last,bytes.length-last);
os.flush();
Thread.sleep(PAUSE);
// Read the response
String response=readResponse(client);
@ -135,5 +133,5 @@ public class SelectChannelServerSslTest extends HttpServerTestBase
public void testAvailable() throws Exception
{
}
}

24
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SslBytesServerTest.java
View File

@ -33,7 +33,6 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.servlet.ServletException;
@ -80,7 +79,12 @@ public class SslBytesServerTest extends SslBytesTest
threadPool = Executors.newCachedThreadPool();
server = new Server();
SelectChannelConnector connector = new SelectChannelConnector(server,true)
File keyStore = MavenTestingUtils.getTestResourceFile("keystore");
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keyStore.getAbsolutePath());
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
SelectChannelConnector connector = new SelectChannelConnector(server, sslContextFactory)
{
@Override
protected SelectChannelEndPoint newEndPoint(SocketChannel channel, ManagedSelector selectSet, SelectionKey key) throws IOException
@ -89,20 +93,12 @@ public class SslBytesServerTest extends SslBytesTest
serverEndPoint.set(endp);
return endp;
}
};
connector.setIdleTimeout(idleTimeout);
// connector.setPort(5870);
};
connector.setIdleTimeout(idleTimeout);
// connector.setPort(5870);
connector.setPort(0);
File keyStore = MavenTestingUtils.getTestResourceFile("keystore");
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keyStore.getAbsolutePath());
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
server.addConnector(connector);
server.setHandler(new AbstractHandler()
{
@ -139,7 +135,7 @@ public class SslBytesServerTest extends SslBytesTest
server.start();
serverPort = connector.getLocalPort();
sslContext = cf.getSslContext();
sslContext = sslContextFactory.getSslContext();
proxy = new SimpleProxy(threadPool, "localhost", serverPort);
proxy.start();

19
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SslSelectChannelTimeoutTest.java
View File

@ -16,7 +16,6 @@ package org.eclipse.jetty.server.ssl;
import java.io.FileInputStream;
import java.net.Socket;
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
@ -38,19 +37,19 @@ public class SslSelectChannelTimeoutTest extends ConnectorTimeoutTest
@BeforeClass
public static void init() throws Exception
{
SelectChannelConnector connector = new SelectChannelConnector(_server,true);
connector.setIdleTimeout(MAX_IDLE_TIME); //250 msec max idle
String keystorePath = System.getProperty("basedir",".") + "/src/test/resources/keystore";
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keystorePath);
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
cf.setTrustStore(keystorePath);
cf.setTrustStorePassword("storepwd");
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystorePath);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
sslContextFactory.setTrustStore(keystorePath);
sslContextFactory.setTrustStorePassword("storepwd");
SelectChannelConnector connector = new SelectChannelConnector(_server, sslContextFactory);
connector.setIdleTimeout(MAX_IDLE_TIME); //250 msec max idle
startServer(connector);
KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
keystore.load(new FileInputStream(connector.getConnectionFactory().getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
keystore.load(new FileInputStream(keystorePath), "storepwd".toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keystore);
__sslContext = SSLContext.getInstance("SSL");

29
jetty-server/src/test/java/org/eclipse/jetty/server/ssl/SslUploadTest.java
View File

@ -14,16 +14,12 @@
package org.eclipse.jetty.server.ssl;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.KeyStore;
import java.util.Arrays;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManagerFactory;
@ -42,6 +38,9 @@ import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @version $Revision$ $Date$
*/
@ -54,17 +53,17 @@ public class SslUploadTest
@BeforeClass
public static void startServer() throws Exception
{
server = new Server();
connector = new SelectChannelConnector(server,true);
server.addConnector(connector);
String keystorePath = System.getProperty("basedir",".") + "/src/test/resources/keystore";
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(keystorePath);
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
cf.setTrustStore(keystorePath);
cf.setTrustStorePassword("storepwd");
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keystorePath);
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
sslContextFactory.setTrustStore(keystorePath);
sslContextFactory.setTrustStorePassword("storepwd");
server = new Server();
connector = new SelectChannelConnector(server, sslContextFactory);
server.addConnector(connector);
server.setHandler(new EmptyHandler());
@ -83,7 +82,7 @@ public class SslUploadTest
public void test() throws Exception
{
KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
keystore.load(new FileInputStream(connector.getConnectionFactory().getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
keystore.load(new FileInputStream(connector.getSslContextFactory().getKeyStorePath()), "storepwd".toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keystore);
SSLContext sslContext = SSLContext.getInstance("SSL");

43
jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java
View File

@ -12,14 +12,6 @@ package org.eclipse.jetty.servlets;
//You may elect to redistribute this code under either of these licenses.
//========================================================================
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
@ -36,10 +28,9 @@ import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
import javax.servlet.DispatcherType;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.DefaultServlet;
import org.eclipse.jetty.servlet.FilterHolder;
@ -58,6 +49,14 @@ import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Test the effects of Gzip filtering when in the context of HTTP/1.1 Pipelining.
*/
@ -73,20 +72,20 @@ public class GzipWithPipeliningTest
{ GzipFilter.GZIP },
{ GzipFilter.DEFLATE + ", " + GzipFilter.GZIP },
{ GzipFilter.GZIP + ", " + GzipFilter.DEFLATE },
{ GzipFilter.DEFLATE }
{ GzipFilter.DEFLATE }
};
return Arrays.asList(data);
}
@Rule
public TestingDir testingdir = new TestingDir();
private Server server;
private URI serverUri;
private String encodingHeader;
public GzipWithPipeliningTest(String encodingHeader)
{
this.encodingHeader = encodingHeader;
@ -114,7 +113,7 @@ public class GzipWithPipeliningTest
// Start Server
server.start();
Connector.NetConnector conn = (Connector.NetConnector)server.getConnectors()[0];
NetworkConnector conn = (NetworkConnector)server.getConnectors()[0];
String host = conn.getHost();
if (host == null)
{
@ -130,13 +129,13 @@ public class GzipWithPipeliningTest
{
server.stop();
}
@Test
public void testGzipThenImagePipelining() throws Exception
{
testingdir.ensureEmpty();
File outputDir = testingdir.getDir();
File outputDir = testingdir.getDir();
PipelineHelper client = new PipelineHelper(serverUri, encodingHeader);
try
@ -193,7 +192,7 @@ public class GzipWithPipeliningTest
// Inter-pipeline delim
line = client.readLine();
assertThat("Inter-pipeline delim should be an empty line with CR+LF",line,is(""));
// Sha1tracking for 1st Request
MessageDigest digestTxt = MessageDigest.getInstance("SHA1");
DigestOutputStream digesterTxt = new DigestOutputStream(new NoOpOutputStream(),digestTxt);
@ -212,7 +211,7 @@ public class GzipWithPipeliningTest
}
IO.copy(uncompressedStream, digesterTxt);
// Read 2nd request http response header
respHeader = client.readResponseHeader();
System.out.println("Response Header #2 --\n" + respHeader);

44
jetty-spdy/spdy-jetty-http/src/main/java/org/eclipse/jetty/spdy/http/ServerHTTPAsyncConnectionFactory.java
View File

@ -1,44 +0,0 @@
//========================================================================
//Copyright 2011-2012 Mort Bay Consulting Pty. Ltd.
//------------------------------------------------------------------------
//All rights reserved. This program and the accompanying materials
//are made available under the terms of the Eclipse Public License v1.0
//and Apache License v2.0 which accompanies this distribution.
//The Eclipse Public License is available at
//http://www.eclipse.org/legal/epl-v10.html
//The Apache License v2.0 is available at
//http://www.opensource.org/licenses/apache2.0.php
//You may elect to redistribute this code under either of these licenses.
//========================================================================
package org.eclipse.jetty.spdy.http;
import java.nio.channels.SocketChannel;
import org.eclipse.jetty.io.AsyncEndPoint;
import org.eclipse.jetty.io.nio.AsyncConnection;
import org.eclipse.jetty.server.AsyncHttpConnection;
import org.eclipse.jetty.spdy.AsyncConnectionFactory;
import org.eclipse.jetty.spdy.SPDYServerConnector;
public class ServerHTTPAsyncConnectionFactory implements AsyncConnectionFactory
{
private final SPDYServerConnector connector;
public ServerHTTPAsyncConnectionFactory(SPDYServerConnector connector)
{
this.connector = connector;
}
public SPDYServerConnector getConnector()
{
return connector;
}
@Override
public AsyncConnection newAsyncConnection(SocketChannel channel, AsyncEndPoint endPoint, Object attachment)
{
return new AsyncHttpConnection(connector, endPoint, connector.getServer());
}
}

24
jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/ConnectionFactory.java
View File

@ -1,24 +0,0 @@
// ========================================================================
// Copyright 2011-2012 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
package org.eclipse.jetty.spdy;
import java.nio.channels.SocketChannel;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
public interface ConnectionFactory
{
public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment);
}

19
jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/NextProtoNegoServerAsyncConnection.java → jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/NextProtoNegoServerConnection.java
View File

@ -21,18 +21,19 @@ import org.eclipse.jetty.io.AbstractConnection;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.npn.NextProtoNego;
import org.eclipse.jetty.server.ConnectionFactory;
import org.eclipse.jetty.util.BufferUtil;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
public class NextProtoNegoServerAsyncConnection extends AbstractConnection implements NextProtoNego.ServerProvider
public class NextProtoNegoServerConnection extends AbstractConnection implements NextProtoNego.ServerProvider
{
private final Logger logger = Log.getLogger(getClass());
private final SocketChannel channel;
private final SPDYServerConnector connector;
private volatile boolean completed;
public NextProtoNegoServerAsyncConnection(SocketChannel channel, EndPoint endPoint, SPDYServerConnector connector)
public NextProtoNegoServerConnection(SocketChannel channel, EndPoint endPoint, SPDYServerConnector connector)
{
super(endPoint, connector.getExecutor());
this.channel = channel;
@ -45,7 +46,7 @@ public class NextProtoNegoServerAsyncConnection extends AbstractConnection imple
super.onOpen();
fillInterested();
}
@Override
public void onFillable()
{
@ -76,10 +77,10 @@ public class NextProtoNegoServerAsyncConnection extends AbstractConnection imple
@Override
public void unsupported()
{
ConnectionFactory asyncConnectionFactory = connector.getDefaultAsyncConnectionFactory();
ConnectionFactory ConnectionFactory = connector.getDefaultConnectionFactory();
EndPoint endPoint = getEndPoint();
Connection connection = asyncConnectionFactory.newConnection(channel, endPoint, connector);
connector.replaceAsyncConnection(endPoint, connection);
Connection connection = ConnectionFactory.newConnection(channel, endPoint, connector);
connector.replaceConnection(endPoint, connection);
completed = true;
}
@ -92,10 +93,10 @@ public class NextProtoNegoServerAsyncConnection extends AbstractConnection imple
@Override
public void protocolSelected(String protocol)
{
ConnectionFactory asyncConnectionFactory = connector.getAsyncConnectionFactory(protocol);
ConnectionFactory ConnectionFactory = connector.getConnectionFactory(protocol);
EndPoint endPoint = getEndPoint();
Connection connection = asyncConnectionFactory.newConnection(channel, endPoint, connector);
connector.replaceAsyncConnection(endPoint, connection);
Connection connection = ConnectionFactory.newConnection(channel, endPoint, connector);
connector.replaceConnection(endPoint, connection);
completed = true;
}
}

5
jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/SPDYClient.java
View File

@ -31,14 +31,15 @@ import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import javax.net.ssl.SSLEngine;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.SelectChannelEndPoint;
import org.eclipse.jetty.io.SelectorManager;
import org.eclipse.jetty.io.StandardByteBufferPool;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.npn.NextProtoNego;
import org.eclipse.jetty.server.ConnectionFactory;
import org.eclipse.jetty.spdy.api.Session;
import org.eclipse.jetty.spdy.api.SessionFrameListener;
import org.eclipse.jetty.spdy.generator.Generator;
@ -174,7 +175,7 @@ public class SPDYClient
{
String peerHost = channel.socket().getInetAddress().getHostAddress();
int peerPort = channel.socket().getPort();
SSLEngine engine = sslContextFactory.newSslEngine(peerHost, peerPort);
SSLEngine engine = sslContextFactory.newSSLEngine(peerHost, peerPort);
engine.setUseClientMode(true);
return engine;
}

133
jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/SPDYServerConnector.java
View File

@ -18,77 +18,44 @@ import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLEngine;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.StandardByteBufferPool;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.npn.NextProtoNego;
import org.eclipse.jetty.server.ConnectionFactory;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.spdy.api.SPDY;
import org.eclipse.jetty.spdy.api.Session;
import org.eclipse.jetty.spdy.api.server.ServerSessionFrameListener;
import org.eclipse.jetty.util.component.AggregateLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.ssl.SslContextFactory;
public class SPDYServerConnector extends SelectChannelConnector
{
private static final Logger logger = Log.getLogger(SPDYServerConnector.class);
// Order is important on server side, so we use a LinkedHashMap
private final Map<String, ConnectionFactory> factories = new LinkedHashMap<>();
private final Queue<Session> sessions = new ConcurrentLinkedQueue<>();
private final ByteBufferPool bufferPool = new StandardByteBufferPool();
private final Executor executor = new LazyExecutor();
private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
private final ServerSessionFrameListener listener;
private final SslContextFactory sslContextFactory;
private volatile ConnectionFactory defaultConnectionFactory;
private volatile int initialWindowSize = 65536;
public SPDYServerConnector(ServerSessionFrameListener listener)
public SPDYServerConnector(Server server, ServerSessionFrameListener listener)
{
this(listener, null);
this(server, null, listener);
}
public SPDYServerConnector(ServerSessionFrameListener listener, SslContextFactory sslContextFactory)
public SPDYServerConnector(Server server, SslContextFactory sslContextFactory, ServerSessionFrameListener listener)
{
super(server, sslContextFactory);
this.listener = listener;
this.sslContextFactory = sslContextFactory;
if (sslContextFactory != null)
addBean(sslContextFactory);
putAsyncConnectionFactory("spdy/3", new ServerSPDYAsyncConnectionFactory(SPDY.V3, bufferPool, executor, scheduler, listener));
putAsyncConnectionFactory("spdy/2", new ServerSPDYAsyncConnectionFactory(SPDY.V2, bufferPool, executor, scheduler, listener));
setDefaultAsyncConnectionFactory(getAsyncConnectionFactory("spdy/2"));
}
public ByteBufferPool getByteBufferPool()
{
return bufferPool;
}
public Executor getExecutor()
{
return executor;
}
public ScheduledExecutorService getScheduler()
{
return scheduler;
putConnectionFactory("spdy/3", new ServerSPDYAsyncConnectionFactory(SPDY.V3, getByteBufferPool(), getExecutor(), getScheduler(), listener));
putConnectionFactory("spdy/2", new ServerSPDYAsyncConnectionFactory(SPDY.V2, getByteBufferPool(), getExecutor(), getScheduler(), listener));
setDefaultConnectionFactory(getConnectionFactory("spdy/2"));
}
public ServerSessionFrameListener getServerSessionFrameListener()
@ -96,11 +63,6 @@ public class SPDYServerConnector extends SelectChannelConnector
return listener;
}
public SslContextFactory getSslContextFactory()
{
return sslContextFactory;
}
@Override
protected void doStart() throws Exception
{
@ -112,83 +74,22 @@ public class SPDYServerConnector extends SelectChannelConnector
protected void doStop() throws Exception
{
closeSessions();
scheduler.shutdown();
super.doStop();
}
@Override
public void join() throws InterruptedException
{
scheduler.awaitTermination(0, TimeUnit.MILLISECONDS);
super.join();
}
public ConnectionFactory getAsyncConnectionFactory(String protocol)
{
synchronized (factories)
{
return factories.get(protocol);
}
}
public ConnectionFactory putAsyncConnectionFactory(String protocol, ConnectionFactory factory)
{
synchronized (factories)
{
return factories.put(protocol, factory);
}
}
public ConnectionFactory removeAsyncConnectionFactory(String protocol)
{
synchronized (factories)
{
return factories.remove(protocol);
}
}
public Map<String, ConnectionFactory> getAsyncConnectionFactories()
{
synchronized (factories)
{
return new LinkedHashMap<>(factories);
}
}
public void clearAsyncConnectionFactories()
{
synchronized (factories)
{
factories.clear();
}
}
protected List<String> provideProtocols()
{
synchronized (factories)
{
return new ArrayList<>(factories.keySet());
}
}
public ConnectionFactory getDefaultAsyncConnectionFactory()
{
return defaultConnectionFactory;
}
public void setDefaultAsyncConnectionFactory(ConnectionFactory defaultConnectionFactory)
{
this.defaultConnectionFactory = defaultConnectionFactory;
return new ArrayList<>(getConnectionFactories().keySet());
}
@Override
protected Connection newConnection(final SocketChannel channel, EndPoint endPoint)
protected Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment)
{
SslContextFactory sslContextFactory = getSslContextFactory();
if (sslContextFactory != null)
{
final SSLEngine engine = newSSLEngine(sslContextFactory, channel);
Executor executor = getExecutor();
SslConnection sslConnection = new SslConnection(bufferPool, executor, endPoint, engine)
SslConnection sslConnection = new SslConnection(getByteBufferPool(), getExecutor(), endPoint, engine)
{
@Override
public void onClose()
@ -199,7 +100,7 @@ public class SPDYServerConnector extends SelectChannelConnector
};
final EndPoint sslEndPoint = sslConnection.getDecryptedEndPoint();
NextProtoNegoServerAsyncConnection connection = new NextProtoNegoServerAsyncConnection(channel, sslEndPoint, this);
NextProtoNegoServerConnection connection = new NextProtoNegoServerConnection(channel, sslEndPoint, this);
sslEndPoint.setConnection(connection);
getSelectorManager().connectionOpened(connection);
@ -209,7 +110,7 @@ public class SPDYServerConnector extends SelectChannelConnector
}
else
{
ConnectionFactory connectionFactory = getDefaultAsyncConnectionFactory();
ConnectionFactory connectionFactory = getDefaultConnectionFactory();
Connection connection = connectionFactory.newConnection(channel, endPoint, this);
endPoint.setConnection(connection);
return connection;
@ -225,7 +126,7 @@ public class SPDYServerConnector extends SelectChannelConnector
{
String peerHost = channel.socket().getInetAddress().getHostAddress();
int peerPort = channel.socket().getPort();
SSLEngine engine = sslContextFactory.newSslEngine(peerHost, peerPort);
SSLEngine engine = sslContextFactory.newSSLEngine(peerHost, peerPort);
engine.setUseClientMode(false);
return engine;
}
@ -265,7 +166,7 @@ public class SPDYServerConnector extends SelectChannelConnector
this.initialWindowSize = initialWindowSize;
}
public void replaceAsyncConnection(EndPoint endPoint, Connection connection)
public void replaceConnection(EndPoint endPoint, Connection connection)
{
Connection oldConnection = endPoint.getConnection();
endPoint.setConnection(connection);

3
jetty-spdy/spdy-jetty/src/main/java/org/eclipse/jetty/spdy/ServerSPDYAsyncConnectionFactory.java
View File

@ -17,9 +17,10 @@ import java.nio.channels.SocketChannel;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.server.ConnectionFactory;
import org.eclipse.jetty.spdy.api.server.ServerSessionFrameListener;
import org.eclipse.jetty.spdy.generator.Generator;
import org.eclipse.jetty.spdy.parser.Parser;

6
jetty-spdy/spdy-jetty/src/test/java/org/eclipse/jetty/spdy/AbstractTest.java
View File

@ -56,13 +56,13 @@ public abstract class AbstractTest
protected InetSocketAddress startServer(short version, ServerSessionFrameListener listener) throws Exception
{
server = new Server();
if (connector == null)
connector = newSPDYServerConnector(listener);
if (listener == null)
listener = connector.getServerSessionFrameListener();
connector.setDefaultAsyncConnectionFactory(new ServerSPDYAsyncConnectionFactory(version, connector.getByteBufferPool(), connector.getExecutor(), connector.getScheduler(), listener));
connector.setDefaultConnectionFactory(new ServerSPDYAsyncConnectionFactory(version, connector.getByteBufferPool(), connector.getExecutor(), connector.getScheduler(), listener));
connector.setPort(0);
server = new Server();
server.addConnector(connector);
server.start();
return new InetSocketAddress("localhost", connector.getLocalPort());
@ -70,7 +70,7 @@ public abstract class AbstractTest
protected SPDYServerConnector newSPDYServerConnector(ServerSessionFrameListener listener)
{
return new SPDYServerConnector(listener);
return new SPDYServerConnector(server, listener);
}
protected Session startClient(InetSocketAddress socketAddress, SessionFrameListener listener) throws Exception

2
jetty-spdy/spdy-jetty/src/test/java/org/eclipse/jetty/spdy/SSLEngineLeakTest.java
View File

@ -31,7 +31,7 @@ public class SSLEngineLeakTest extends AbstractTest
protected SPDYServerConnector newSPDYServerConnector(ServerSessionFrameListener listener)
{
SslContextFactory sslContextFactory = newSslContextFactory();
return new SPDYServerConnector(listener, sslContextFactory);
return new SPDYServerConnector(server, sslContextFactory, listener);
}
@Override

2
jetty-spdy/spdy-jetty/src/test/java/org/eclipse/jetty/spdy/SSLSynReplyTest.java
View File

@ -27,7 +27,7 @@ public class SSLSynReplyTest extends SynReplyTest
protected SPDYServerConnector newSPDYServerConnector(ServerSessionFrameListener listener)
{
SslContextFactory sslContextFactory = newSslContextFactory();
return new SPDYServerConnector(listener, sslContextFactory);
return new SPDYServerConnector(server, sslContextFactory, listener);
}
@Override

20
jetty-util/src/main/java/org/eclipse/jetty/util/ssl/SslContextFactory.java
View File

@ -39,7 +39,6 @@ import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.net.ssl.CertPathTrustManagerParameters;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
@ -295,7 +294,7 @@ public class SslContextFactory extends AbstractLifeCycle
_context = (_sslProvider == null)?SSLContext.getInstance(_sslProtocol):SSLContext.getInstance(_sslProtocol,_sslProvider);
_context.init(keyManagers,trustManagers,secureRandom);
SSLEngine engine=newSslEngine();
SSLEngine engine= newSSLEngine();
LOG.info("Enabled Protocols {} of {}",Arrays.asList(engine.getEnabledProtocols()),Arrays.asList(engine.getSupportedProtocols()));
if (LOG.isDebugEnabled())
@ -1390,20 +1389,19 @@ public class SslContextFactory extends AbstractLifeCycle
}
/* ------------------------------------------------------------ */
public SSLEngine newSslEngine(String host,int port)
public SSLEngine newSSLEngine(String host, int port)
{
if (!isRunning())
throw new IllegalStateException("!STARTED");
SSLEngine sslEngine=isSessionCachingEnabled()
?_context.createSSLEngine(host, port)
:_context.createSSLEngine();
customize(sslEngine);
return sslEngine;
}
/* ------------------------------------------------------------ */
public SSLEngine newSslEngine()
public SSLEngine newSSLEngine()
{
if (!isRunning())
throw new IllegalStateException("!STARTED");
@ -1428,17 +1426,11 @@ public class SslContextFactory extends AbstractLifeCycle
}
/* ------------------------------------------------------------ */
public SSLEngine createSSLEngine(InetSocketAddress address) throws IOException
public SSLEngine newSSLEngine(InetSocketAddress address)
{
SSLEngine engine = (address != null)
?newSslEngine(address.getAddress().getHostAddress(), address.getPort())
:newSslEngine();
engine.setUseClientMode(false);
customize(engine);
return engine;
return address != null ? newSSLEngine(address.getAddress().getHostAddress(), address.getPort()) : newSSLEngine();
}
/* ------------------------------------------------------------ */
@Override
public String toString()

147
jetty-webapp/src/main/java/org/eclipse/jetty/webapp/WebInfConfiguration.java
View File

@ -5,11 +5,11 @@ package org.eclipse.jetty.webapp;
//All rights reserved. This program and the accompanying materials
//are made available under the terms of the Eclipse Public License v1.0
//and Apache License v2.0 which accompanies this distribution.
//The Eclipse Public License is available at
//The Eclipse Public License is available at
//http://www.eclipse.org/legal/epl-v10.html
//The Apache License v2.0 is available at
//http://www.opensource.org/licenses/apache2.0.php
//You may elect to redistribute this code under either of these licenses.
//You may elect to redistribute this code under either of these licenses.
//========================================================================
import java.io.File;
@ -23,6 +23,7 @@ import java.util.List;
import java.util.regex.Pattern;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.util.IO;
import org.eclipse.jetty.util.PatternMatcher;
@ -40,15 +41,15 @@ public class WebInfConfiguration extends AbstractConfiguration
public static final String TEMPDIR_CONFIGURED = "org.eclipse.jetty.tmpdirConfigured";
public static final String CONTAINER_JAR_PATTERN = "org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern";
public static final String WEBINF_JAR_PATTERN = "org.eclipse.jetty.server.webapp.WebInfIncludeJarPattern";
/**
* If set, to a list of URLs, these resources are added to the context
* resource base as a resource collection.
* resource base as a resource collection.
*/
public static final String RESOURCE_URLS = "org.eclipse.jetty.resources";
protected Resource _preUnpackBaseResource;
@Override
public void preConfigure(final WebAppContext context) throws Exception
{
@ -56,16 +57,16 @@ public class WebInfConfiguration extends AbstractConfiguration
File work = findWorkDirectory(context);
if (work != null)
makeTempDirectory(work, context, false);
//Make a temp directory for the webapp if one is not already set
resolveTempDirectory(context);
//Extract webapp if necessary
unpack (context);
//Apply an initial ordering to the jars which governs which will be scanned for META-INF
//info and annotations. The ordering is based on inclusion patterns.
//info and annotations. The ordering is based on inclusion patterns.
String tmp = (String)context.getAttribute(WEBINF_JAR_PATTERN);
Pattern webInfPattern = (tmp==null?null:Pattern.compile(tmp));
tmp = (String)context.getAttribute(CONTAINER_JAR_PATTERN);
@ -78,7 +79,7 @@ public class WebInfConfiguration extends AbstractConfiguration
public void matched(URI uri) throws Exception
{
context.getMetaData().addContainerJar(Resource.newResource(uri));
}
}
};
ClassLoader loader = context.getClassLoader();
while (loader != null && (loader instanceof URLClassLoader))
@ -90,21 +91,21 @@ public class WebInfConfiguration extends AbstractConfiguration
int i=0;
for (URL u : urls)
{
try
try
{
containerUris[i] = u.toURI();
}
catch (URISyntaxException e)
{
containerUris[i] = new URI(u.toString().replaceAll(" ", "%20"));
}
}
i++;
}
containerJarNameMatcher.match(containerPattern, containerUris, false);
}
loader = loader.getParent();
}
//Apply ordering to WEB-INF/lib jars
PatternMatcher webInfJarNameMatcher = new PatternMatcher ()
{
@ -112,10 +113,10 @@ public class WebInfConfiguration extends AbstractConfiguration
public void matched(URI uri) throws Exception
{
context.getMetaData().addWebInfJar(Resource.newResource(uri));
}
}
};
List<Resource> jars = findJars(context);
//Convert to uris for matching
URI[] uris = null;
if (jars != null)
@ -127,9 +128,9 @@ public class WebInfConfiguration extends AbstractConfiguration
uris[i++] = r.getURI();
}
}
webInfJarNameMatcher.match(webInfPattern, uris, true); //null is inclusive, no pattern == all jars match
webInfJarNameMatcher.match(webInfPattern, uris, true); //null is inclusive, no pattern == all jars match
}
@Override
public void configure(WebAppContext context) throws Exception
@ -157,7 +158,7 @@ public class WebInfConfiguration extends AbstractConfiguration
if (lib.exists() || lib.isDirectory())
((WebAppClassLoader)context.getClassLoader()).addJars(lib);
}
// Look for extra resource
@SuppressWarnings("unchecked")
List<Resource> resources = (List<Resource>)context.getAttribute(RESOURCE_URLS);
@ -177,23 +178,23 @@ public class WebInfConfiguration extends AbstractConfiguration
{
// delete temp directory if we had to create it or if it isn't called work
Boolean tmpdirConfigured = (Boolean)context.getAttribute(TEMPDIR_CONFIGURED);
if (context.getTempDirectory()!=null && (tmpdirConfigured == null || !tmpdirConfigured.booleanValue()) && !isTempWorkDirectory(context.getTempDirectory()))
{
IO.delete(context.getTempDirectory());
context.setTempDirectory(null);
//clear out the context attributes for the tmp dir only if we had to
//create the tmp dir
context.setAttribute(TEMPDIR_CONFIGURED, null);
context.setAttribute(WebAppContext.TEMPDIR, null);
}
//reset the base resource back to what it was before we did any unpacking of resources
context.setBaseResource(_preUnpackBaseResource);
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.webapp.AbstractConfiguration#cloneConfigure(org.eclipse.jetty.webapp.WebAppContext, org.eclipse.jetty.webapp.WebAppContext)
@ -217,7 +218,7 @@ public class WebInfConfiguration extends AbstractConfiguration
* Get a temporary directory in which to unpack the war etc etc.
* The algorithm for determining this is to check these alternatives
* in the order shown:
*
*
* <p>A. Try to use an explicit directory specifically for this webapp:</p>
* <ol>
* <li>
@ -229,8 +230,8 @@ public class WebInfConfiguration extends AbstractConfiguration
* this webapp && exists && writeable, then use it. Do NOT set delete on exit.
* </li>
* </ol>
*
* <p>B. Create a directory based on global settings. The new directory
*
* <p>B. Create a directory based on global settings. The new directory
* will be called "Jetty_"+host+"_"+port+"__"+context+"_"+virtualhost
* Work out where to create this directory:
* <ol>
@ -257,7 +258,7 @@ public class WebInfConfiguration extends AbstractConfiguration
context.setAttribute(TEMPDIR_CONFIGURED, Boolean.TRUE);
return; // Already have a suitable tmp dir configured
}
// No temp directory configured, try to establish one.
// First we check the context specific, javax.servlet specified, temp directory attribute
@ -322,7 +323,7 @@ public class WebInfConfiguration extends AbstractConfiguration
}
}
}
/**
* Given an Object, return File reference for object.
* Typically used to convert anonymous Object from getAttribute() calls to a File object.
@ -353,7 +354,7 @@ public class WebInfConfiguration extends AbstractConfiguration
{
if (parent != null && parent.exists() && parent.canWrite() && parent.isDirectory())
{
String temp = getCanonicalNameForWebAppTmpDir(context);
String temp = getCanonicalNameForWebAppTmpDir(context);
File tmpDir = new File(parent,temp);
if (deleteExisting && tmpDir.exists())
@ -362,7 +363,7 @@ public class WebInfConfiguration extends AbstractConfiguration
{
if(LOG.isDebugEnabled())LOG.debug("Failed to delete temp dir "+tmpDir);
}
//If we can't delete the existing tmp dir, create a new one
if (tmpDir.exists())
{
@ -371,9 +372,9 @@ public class WebInfConfiguration extends AbstractConfiguration
if (tmpDir.exists())
IO.delete(tmpDir);
LOG.warn("Can't reuse "+old+", using "+tmpDir);
}
}
}
if (!tmpDir.exists())
tmpDir.mkdir();
@ -388,13 +389,13 @@ public class WebInfConfiguration extends AbstractConfiguration
context.setTempDirectory(tmpDir);
}
}
public void unpack (WebAppContext context) throws IOException
{
Resource web_app = context.getBaseResource();
_preUnpackBaseResource = context.getBaseResource();
if (web_app == null)
{
String war = context.getWar();
@ -425,7 +426,7 @@ public class WebInfConfiguration extends AbstractConfiguration
if (web_app.exists() && (
(context.isCopyWebDir() && web_app.getFile() != null && web_app.getFile().isDirectory()) ||
(context.isExtractWAR() && web_app.getFile() != null && !web_app.getFile().isDirectory()) ||
(context.isExtractWAR() && web_app.getFile() == null) ||
(context.isExtractWAR() && web_app.getFile() == null) ||
!web_app.isDirectory())
)
{
@ -443,7 +444,7 @@ public class WebInfConfiguration extends AbstractConfiguration
extractedWebAppDir=sibling;
}
}
if (extractedWebAppDir==null)
// Then extract it if necessary to the temporary location
extractedWebAppDir= new File(context.getTempDirectory(), "webapp");
@ -459,13 +460,13 @@ public class WebInfConfiguration extends AbstractConfiguration
//Use a sentinel file that will exist only whilst the extraction is taking place.
//This will help us detect interrupted extractions.
File extractionLock = new File (context.getTempDirectory(), ".extract_lock");
if (!extractedWebAppDir.exists())
{
//it hasn't been extracted before so extract it
extractionLock.createNewFile();
extractionLock.createNewFile();
extractedWebAppDir.mkdir();
LOG.info("Extract " + web_app + " to " + extractedWebAppDir);
LOG.info("Extract " + web_app + " to " + extractedWebAppDir);
Resource jar_web_app = JarResource.newJarResource(web_app);
jar_web_app.copyTo(extractedWebAppDir);
extractionLock.delete();
@ -484,7 +485,7 @@ public class WebInfConfiguration extends AbstractConfiguration
extractionLock.delete();
}
}
}
}
web_app = Resource.newResource(extractedWebAppDir.getCanonicalPath());
}
@ -494,13 +495,13 @@ public class WebInfConfiguration extends AbstractConfiguration
LOG.warn("Web application not found " + war);
throw new java.io.FileNotFoundException(war);
}
context.setBaseResource(web_app);
if (LOG.isDebugEnabled())
LOG.debug("webapp=" + web_app);
}
// Do we need to extract WEB-INF/lib?
if (context.isCopyWebInf() && !context.isCopyWebDir())
@ -544,11 +545,11 @@ public class WebInfConfiguration extends AbstractConfiguration
if (LOG.isDebugEnabled())
LOG.debug("context.resourcebase = "+rc);
context.setBaseResource(rc);
context.setBaseResource(rc);
}
}
public File findWorkDirectory (WebAppContext context) throws IOException
{
if (context.getBaseResource() != null)
@ -561,8 +562,8 @@ public class WebInfConfiguration extends AbstractConfiguration
}
return null;
}
/**
* Check if the tmpDir itself is called "work", or if the tmpDir
* is in a directory called "work".
@ -579,13 +580,13 @@ public class WebInfConfiguration extends AbstractConfiguration
return false;
return (t.getName().equalsIgnoreCase("work"));
}
/**
* Create a canonical name for a webapp temp directory.
* The form of the name is:
* <code>"Jetty_"+host+"_"+port+"__"+resourceBase+"_"+context+"_"+virtualhost+base36_hashcode_of_whole_string</code>
*
*
* host and port uniquely identify the server
* context and virtual host uniquely identify the webapp
* @return the canonical name for the webapp temp directory
@ -594,8 +595,8 @@ public class WebInfConfiguration extends AbstractConfiguration
{
StringBuffer canonicalName = new StringBuffer();
canonicalName.append("jetty-");
//get the host and the port from the first connector
//get the host and the port from the first connector
Server server=context.getServer();
if (server!=null)
{
@ -606,9 +607,9 @@ public class WebInfConfiguration extends AbstractConfiguration
//Get the host
String host=null;
int port=0;
if (connectors!=null && (connectors[0] instanceof Connector.NetConnector))
if (connectors!=null && (connectors[0] instanceof NetworkConnector))
{
Connector.NetConnector connector = (Connector.NetConnector)connectors[0];
NetworkConnector connector = (NetworkConnector)connectors[0];
host=connector.getHost();
port=connector.getLocalPort();
if (port < 0)
@ -617,18 +618,18 @@ public class WebInfConfiguration extends AbstractConfiguration
if (host == null)
host = "0.0.0.0";
canonicalName.append(host);
//Get the port
canonicalName.append("-");
//if not available (eg no connectors or connector not started),
//if not available (eg no connectors or connector not started),
//try getting one that was configured.
canonicalName.append(port);
canonicalName.append("-");
}
}
//Resource base
try
{
@ -637,11 +638,11 @@ public class WebInfConfiguration extends AbstractConfiguration
{
if (context.getWar()==null || context.getWar().length()==0)
resource=context.newResource(context.getResourceBase());
// Set dir or WAR
resource = context.newResource(context.getWar());
}
String tmp = URIUtil.decodePath(resource.getURL().getPath());
if (tmp.endsWith("/"))
tmp = tmp.substring(0, tmp.length()-1);
@ -656,13 +657,13 @@ public class WebInfConfiguration extends AbstractConfiguration
{
LOG.warn("Can't generate resourceBase as part of webapp tmp dir name", e);
}
//Context name
String contextPath = context.getContextPath();
contextPath=contextPath.replace('/','_');
contextPath=contextPath.replace('\\','_');
canonicalName.append(contextPath);
//Virtual host (if there is one)
canonicalName.append("-");
String[] vhosts = context.getVirtualHosts();
@ -670,43 +671,43 @@ public class WebInfConfiguration extends AbstractConfiguration
canonicalName.append("any");
else
canonicalName.append(vhosts[0]);
// sanitize
for (int i=0;i<canonicalName.length();i++)
{
char c=canonicalName.charAt(i);
if (!Character.isJavaIdentifierPart(c) && "-.".indexOf(c)<0)
canonicalName.setCharAt(i,'.');
}
}
canonicalName.append("-");
return canonicalName.toString();
}
/**
* Look for jars in WEB-INF/lib
* @param context
* @return the list of jar resources found within context
* @return the list of jar resources found within context
* @throws Exception
*/
protected List<Resource> findJars (WebAppContext context)
protected List<Resource> findJars (WebAppContext context)
throws Exception
{
List<Resource> jarResources = new ArrayList<Resource>();
Resource web_inf = context.getWebInf();
if (web_inf==null || !web_inf.exists())
return null;
Resource web_inf_lib = web_inf.addPath("/lib");
if (web_inf_lib.exists() && web_inf_lib.isDirectory())
{
String[] files=web_inf_lib.list();
for (int f=0;files!=null && f<files.length;f++)
{
try
try
{
Resource file = web_inf_lib.addPath(files[f]);
String fnlc = file.getName().toLowerCase();

6
jetty-websocket/websocket-client/src/main/java/org/eclipse/jetty/websocket/client/io/WebSocketClientSelectorManager.java
View File

@ -21,18 +21,16 @@ import java.nio.channels.SocketChannel;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicReference;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLException;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.SelectChannelEndPoint;
import org.eclipse.jetty.io.SelectorManager;
import org.eclipse.jetty.io.ssl.SslConnection;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.websocket.api.WebSocketConnection;
import org.eclipse.jetty.websocket.api.WebSocketPolicy;
import org.eclipse.jetty.websocket.client.WebSocketClient;
import org.eclipse.jetty.websocket.client.WebSocketClientFactory;
@ -146,7 +144,7 @@ public class WebSocketClientSelectorManager extends SelectorManager
{
String peerHost = channel.socket().getInetAddress().getHostAddress();
int peerPort = channel.socket().getPort();
SSLEngine engine = sslContextFactory.newSslEngine(peerHost,peerPort);
SSLEngine engine = sslContextFactory.newSSLEngine(peerHost, peerPort);
engine.setUseClientMode(true);
return engine;
}

11
jetty-websocket/websocket-server/src/test/java/org/eclipse/jetty/websocket/server/WebSocketOverSSLTest.java
View File

@ -22,7 +22,6 @@ import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.server.SelectChannelConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ssl.SslSelectChannelConnector;
import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
import org.eclipse.jetty.util.Callback;
import org.eclipse.jetty.util.FutureCallback;
@ -95,13 +94,13 @@ public class WebSocketOverSSLTest
private void startServer(final Object websocket) throws Exception
{
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(MavenTestingUtils.getTestResourceFile("keystore").getAbsolutePath());
sslContextFactory.setKeyStorePassword("storepwd");
sslContextFactory.setKeyManagerPassword("keypwd");
_server = new Server();
SelectChannelConnector connector = new SelectChannelConnector(_server,true);
SelectChannelConnector connector = new SelectChannelConnector(_server, sslContextFactory);
_server.addConnector(connector);
SslContextFactory cf = connector.getConnectionFactory().getSslContextFactory();
cf.setKeyStorePath(MavenTestingUtils.getTestResourceFile("keystore").getAbsolutePath());
cf.setKeyStorePassword("storepwd");
cf.setKeyManagerPassword("keypwd");
_server.setHandler(new WebSocketHandler.Simple(websocket.getClass()));
_server.start();
_port = connector.getLocalPort();