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