View Javadoc

1   // ========================================================================
2   // Copyright (c) 2006-2009 Mort Bay Consulting Pty. Ltd.
3   // ------------------------------------------------------------------------
4   // All rights reserved. This program and the accompanying materials
5   // are made available under the terms of the Eclipse Public License v1.0
6   // and Apache License v2.0 which accompanies this distribution.
7   // The Eclipse Public License is available at
8   // http://www.eclipse.org/legal/epl-v10.html
9   // The Apache License v2.0 is available at
10  // http://www.opensource.org/licenses/apache2.0.php
11  // You may elect to redistribute this code under either of these licenses.
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  
21  import org.eclipse.jetty.io.ByteArrayBuffer;
22  import org.eclipse.jetty.io.ByteArrayEndPoint;
23  import org.eclipse.jetty.io.Connection;
24  import org.eclipse.jetty.util.StringUtil;
25  import org.eclipse.jetty.util.log.Log;
26  
27  public class LocalConnector extends AbstractConnector
28  {
29      private final BlockingQueue<Request> requests = new LinkedBlockingQueue<Request>();
30  
31      public Object getConnection()
32      {
33          return this;
34      }
35  
36      /**
37       * @deprecated Not needed anymore, as there is no need to reopen the connector to reset its state
38       */
39      @Deprecated
40      public void reopen()
41      {
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.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();
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              this.requestsBuffer = requestsBuffer;
100             this.keepOpen = keepOpen;
101             this.latch = latch;
102         }
103 
104         public void run()
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)
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                 if (latch != null)
149                     latch.countDown();
150             }
151         }
152 
153         public ByteArrayBuffer getResponsesBuffer()
154         {
155             return responsesBuffer;
156         }
157     }
158 }