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 connectionUpgraded(getConnection(),connection);
114 super.setConnection(connection);
115 }
116 };
117
118 endPoint.setGrowOutput(true);
119 HttpConnection connection = new BlockingHttpConnection(LocalConnector.this, endPoint, getServer());
120 endPoint.setConnection(connection);
121 connectionOpened(connection);
122
123 boolean leaveOpen = _keepOpen;
124 try
125 {
126 while (endPoint.getIn().length() > 0 && endPoint.isOpen())
127 {
128 while (true)
129 {
130 final Connection con = endPoint.getConnection();
131 final Connection next = con.handle();
132 if (next!=con)
133 {
134 endPoint.setConnection(next);
135 continue;
136 }
137 break;
138 }
139 }
140 }
141 catch (IOException x)
142 {
143 LOG.debug(x);
144 leaveOpen = false;
145 }
146 catch (Exception x)
147 {
148 LOG.warn(x);
149 leaveOpen = false;
150 }
151 finally
152 {
153 if (!leaveOpen)
154 connectionClosed(connection);
155 _responsesBuffer = endPoint.getOut();
156 }
157 }
158 finally
159 {
160 if (_latch != null)
161 _latch.countDown();
162 }
163 }
164
165 public ByteArrayBuffer getResponsesBuffer()
166 {
167 return _responsesBuffer;
168 }
169 }
170 }