org.eclipse.jetty.server.LocalConnector Maven / Gradle / Ivy
//
// ========================================================================
// Copyright (c) 1995-2013 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;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.io.ByteArrayEndPoint;
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.ssl.SslContextFactory;
import org.eclipse.jetty.util.thread.Scheduler;
public class LocalConnector extends AbstractConnector
{
private final BlockingQueue _connects = new LinkedBlockingQueue<>();
public LocalConnector(Server server, Executor executor, Scheduler scheduler, ByteBufferPool pool, int acceptors, ConnectionFactory... factories)
{
super(server,executor,scheduler,pool,acceptors,factories);
setIdleTimeout(30000);
}
public LocalConnector(Server server)
{
this(server, null, null, null, 0, new HttpConnectionFactory());
}
public LocalConnector(Server server, SslContextFactory sslContextFactory)
{
this(server, null, null, null, 0,AbstractConnectionFactory.getFactories(sslContextFactory,new HttpConnectionFactory()));
}
public LocalConnector(Server server, ConnectionFactory connectionFactory)
{
this(server, null, null, null, 0, connectionFactory);
}
public LocalConnector(Server server, ConnectionFactory connectionFactory, SslContextFactory sslContextFactory)
{
this(server, null, null, null, 0, AbstractConnectionFactory.getFactories(sslContextFactory,connectionFactory));
}
@Override
public Object getTransport()
{
return this;
}
/** Sends requests and get responses based on thread activity.
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
*
* This methods waits until the connection is closed or
* is idle for 1s before returning the responses.
* @param requests the requests
* @return the responses
* @throws Exception if the requests fail
*/
public String getResponses(String requests) throws Exception
{
return getResponses(requests, 5, TimeUnit.SECONDS);
}
/** Sends requests and get responses based on thread activity.
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
*
* 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
* @param units The units of idleFor
* @return the responses
* @throws Exception if the requests fail
*/
public String getResponses(String requests,long idleFor,TimeUnit units) throws Exception
{
ByteBuffer result = getResponses(BufferUtil.toBuffer(requests,StandardCharsets.UTF_8),idleFor,units);
return result==null?null:BufferUtil.toString(result,StandardCharsets.UTF_8);
}
/** Sends requests and get's responses based on thread activity.
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
*
* This methods waits until the connection is closed or
* is idle for 1s before returning the responses.
* @param requestsBuffer the requests
* @return the responses
* @throws Exception if the requests fail
*/
public ByteBuffer getResponses(ByteBuffer requestsBuffer) throws Exception
{
return getResponses(requestsBuffer, 5, TimeUnit.SECONDS);
}
/** Sends requests and get's responses based on thread activity.
* Returns all the responses received once the thread activity has
* returned to the level it was before the requests.
*
* 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
* @param units The units of idleFor
* @return the responses
* @throws Exception if the requests fail
*/
public ByteBuffer getResponses(ByteBuffer requestsBuffer,long idleFor,TimeUnit units) throws Exception
{
LOG.debug("requests {}", BufferUtil.toUTF8String(requestsBuffer));
LocalEndPoint endp = executeRequest(requestsBuffer);
endp.waitUntilClosedOrIdleFor(idleFor,units);
ByteBuffer responses = endp.takeOutput();
endp.getConnection().close();
LOG.debug("responses {}", BufferUtil.toUTF8String(responses));
return responses;
}
/**
* Execute a request and return the EndPoint through which
* responses can be received.
* @param rawRequest the request
* @return the local endpoint
*/
public LocalEndPoint executeRequest(String rawRequest)
{
return executeRequest(BufferUtil.toBuffer(rawRequest, StandardCharsets.UTF_8));
}
private LocalEndPoint executeRequest(ByteBuffer rawRequest)
{
LocalEndPoint endp = new LocalEndPoint();
endp.setInput(rawRequest);
_connects.add(endp);
return endp;
}
@Override
protected void accept(int acceptorID) throws IOException, InterruptedException
{
LOG.debug("accepting {}", acceptorID);
LocalEndPoint endPoint = _connects.take();
endPoint.onOpen();
onEndPointOpened(endPoint);
Connection connection = getDefaultConnectionFactory().newConnection(this, endPoint);
endPoint.setConnection(connection);
// connectionOpened(connection);
connection.onOpen();
}
public class LocalEndPoint extends ByteArrayEndPoint
{
private final CountDownLatch _closed = new CountDownLatch(1);
public LocalEndPoint()
{
super(getScheduler(), LocalConnector.this.getIdleTimeout());
setGrowOutput(true);
}
public void addInput(String s)
{
// TODO this is a busy wait
while(getIn()==null || BufferUtil.hasContent(getIn()))
Thread.yield();
setInput(BufferUtil.toBuffer(s, StandardCharsets.UTF_8));
}
@Override
public void close()
{
boolean wasOpen=isOpen();
super.close();
if (wasOpen)
{
// connectionClosed(getConnection());
getConnection().onClose();
onClose();
}
}
@Override
public void onClose()
{
LocalConnector.this.onEndPointClosed(this);
super.onClose();
_closed.countDown();
}
@Override
public void shutdownOutput()
{
super.shutdownOutput();
close();
}
public void waitUntilClosed()
{
while (isOpen())
{
try
{
if (!_closed.await(10,TimeUnit.SECONDS))
break;
}
catch(Exception e)
{
LOG.warn(e);
}
}
}
public void waitUntilClosedOrIdleFor(long idleFor,TimeUnit units)
{
Thread.yield();
int size=getOutput().remaining();
while (isOpen())
{
try
{
if (!_closed.await(idleFor,units))
{
if (size==getOutput().remaining())
{
LOG.debug("idle for {} {}",idleFor,units);
return;
}
size=getOutput().remaining();
}
}
catch(Exception e)
{
LOG.warn(e);
}
}
}
}
}