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==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 }