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  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.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              this.requestsBuffer = requestsBuffer;
98              this.keepOpen = keepOpen;
99              this.latch = latch;
100         }
101 
102         public void run()
103         {
104             ByteArrayEndPoint endPoint = new ByteArrayEndPoint(requestsBuffer.asArray(), 1024)
105             {
106                 @Override
107                 public void setConnection(Connection connection)
108                 {
109                     connectionUpgraded(getConnection(),connection);
110                     super.setConnection(connection);
111                 }
112             };
113             
114             endPoint.setGrowOutput(true);
115             HttpConnection connection = new HttpConnection(LocalConnector.this, endPoint, getServer());
116             endPoint.setConnection(connection);
117             connectionOpened(connection);
118             
119             boolean leaveOpen = keepOpen;
120             try
121             {
122                 while (endPoint.getIn().length() > 0 && endPoint.isOpen())
123                 {
124                     while (true)
125                     {
126                         final Connection con = endPoint.getConnection();
127                         final Connection next = con.handle();
128                         if (next!=con)
129                         {  
130                             endPoint.setConnection(next);
131                             continue;
132                         }
133                         break;
134                     }
135                 }
136             }
137             catch (Exception x)
138             {
139                 leaveOpen = false;
140             }
141             finally
142             {
143                 if (!leaveOpen)
144                     connectionClosed(connection);
145                 responsesBuffer = endPoint.getOut();
146                 if (latch != null)
147                     latch.countDown();
148             }
149         }
150 
151         public ByteArrayBuffer getResponsesBuffer()
152         {
153             return responsesBuffer;
154         }
155     }
156 }