1
2
3
4
5
6
7
8
9
10
11
12
13
14 package org.eclipse.jetty.server;
15
16 import java.io.IOException;
17 import java.util.concurrent.BlockingQueue;
18 import java.util.concurrent.CountDownLatch;
19 import java.util.concurrent.LinkedBlockingQueue;
20 import java.util.concurrent.TimeUnit;
21
22 import org.eclipse.jetty.io.ByteArrayBuffer;
23 import org.eclipse.jetty.io.ByteArrayEndPoint;
24 import org.eclipse.jetty.io.Connection;
25 import org.eclipse.jetty.util.StringUtil;
26 import org.eclipse.jetty.util.log.Log;
27 import org.eclipse.jetty.util.log.Logger;
28
29 public class LocalConnector extends AbstractConnector
30 {
31 private static final Logger LOG = Log.getLogger(LocalConnector.class);
32 private final BlockingQueue<Request> _requests = new LinkedBlockingQueue<Request>();
33
34 public LocalConnector()
35 {
36 setMaxIdleTime(30000);
37 }
38
39 public Object getConnection()
40 {
41 return this;
42 }
43
44 public String getResponses(String requests) throws Exception
45 {
46 return getResponses(requests, false);
47 }
48
49 public String getResponses(String requests, boolean keepOpen) throws Exception
50 {
51 ByteArrayBuffer result = getResponses(new ByteArrayBuffer(requests, StringUtil.__ISO_8859_1), keepOpen);
52 return result==null?null:result.toString(StringUtil.__ISO_8859_1);
53 }
54
55 public ByteArrayBuffer getResponses(ByteArrayBuffer requestsBuffer, boolean keepOpen) throws Exception
56 {
57 CountDownLatch latch = new CountDownLatch(1);
58 Request request = new Request(requestsBuffer, keepOpen, latch);
59 _requests.add(request);
60 latch.await(getMaxIdleTime(),TimeUnit.MILLISECONDS);
61 return request.getResponsesBuffer();
62 }
63
64 @Override
65 protected void accept(int acceptorID) throws IOException, InterruptedException
66 {
67 Request request = _requests.take();
68 getThreadPool().dispatch(request);
69 }
70
71 public void open() throws IOException
72 {
73 }
74
75 public void close() throws IOException
76 {
77 }
78
79 public int getLocalPort()
80 {
81 return -1;
82 }
83
84 public void executeRequest(String rawRequest) throws IOException
85 {
86 Request request = new Request(new ByteArrayBuffer(rawRequest, "UTF-8"), true, null);
87 _requests.add(request);
88 }
89
90 private class Request implements Runnable
91 {
92 private final ByteArrayBuffer _requestsBuffer;
93 private final boolean _keepOpen;
94 private final CountDownLatch _latch;
95 private volatile ByteArrayBuffer _responsesBuffer;
96
97 private Request(ByteArrayBuffer requestsBuffer, boolean keepOpen, CountDownLatch latch)
98 {
99 _requestsBuffer = requestsBuffer;
100 _keepOpen = keepOpen;
101 _latch = latch;
102 }
103
104 public void run()
105 {
106 try
107 {
108 ByteArrayEndPoint endPoint = new ByteArrayEndPoint(_requestsBuffer.asArray(), 1024)
109 {
110 @Override
111 public void setConnection(Connection connection)
112 {
113 if (getConnection()!=null && connection!=getConnection())
114 connectionUpgraded(getConnection(),connection);
115 super.setConnection(connection);
116 }
117 };
118
119 endPoint.setGrowOutput(true);
120 AbstractHttpConnection connection = new BlockingHttpConnection(LocalConnector.this, endPoint, getServer());
121 endPoint.setConnection(connection);
122 connectionOpened(connection);
123
124 boolean leaveOpen = _keepOpen;
125 try
126 {
127 while (endPoint.getIn().length() > 0 && endPoint.isOpen())
128 {
129 while (true)
130 {
131 final Connection con = endPoint.getConnection();
132 final Connection next = con.handle();
133 if (next!=con)
134 {
135 endPoint.setConnection(next);
136 continue;
137 }
138 break;
139 }
140 }
141 }
142 catch (IOException x)
143 {
144 LOG.debug(x);
145 leaveOpen = false;
146 }
147 catch (Exception x)
148 {
149 LOG.warn(x);
150 leaveOpen = false;
151 }
152 finally
153 {
154 if (!leaveOpen)
155 connectionClosed(connection);
156 _responsesBuffer = endPoint.getOut();
157 }
158 }
159 finally
160 {
161 if (_latch != null)
162 _latch.countDown();
163 }
164 }
165
166 public ByteArrayBuffer getResponsesBuffer()
167 {
168 return _responsesBuffer;
169 }
170 }
171 }