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