View Javadoc

1   // ========================================================================
2   // Copyright (c) 2004-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.http;
15  
16  import org.eclipse.jetty.io.Buffer;
17  import org.eclipse.jetty.io.Buffers;
18  import org.eclipse.jetty.io.ThreadLocalBuffers;
19  import org.eclipse.jetty.util.component.AbstractLifeCycle;
20  
21  /* ------------------------------------------------------------ */
22  /** Abstract Buffer pool.
23   * simple unbounded pool of buffers for header, request and response sizes.
24   *
25   */
26  public abstract class HttpBuffers extends AbstractLifeCycle
27  {
28      
29      private final ThreadLocalBuffers _requestBuffers = new ThreadLocalBuffers()
30      {
31          @Override
32          protected Buffer newBuffer(int size)
33          {
34              return newRequestBuffer(size);
35          }
36  
37          @Override
38          protected Buffer newHeader(int size)
39          {
40              return newRequestHeader(size);
41          }
42          @Override
43          protected boolean isHeader(Buffer buffer)
44          {
45              return isRequestHeader(buffer);
46          }
47      };
48      
49      private final ThreadLocalBuffers _responseBuffers = new ThreadLocalBuffers()
50      {
51          @Override
52          protected Buffer newBuffer(int size)
53          {
54              return newResponseBuffer(size);
55          }
56  
57          @Override
58          protected Buffer newHeader(int size)
59          {
60              return newResponseHeader(size);
61          }
62          @Override
63          protected boolean isHeader(Buffer buffer)
64          {
65              return isResponseHeader(buffer);
66          }
67      };
68      
69      public HttpBuffers()
70      {
71          super();
72          _requestBuffers.setBufferSize(8*1024);
73          _requestBuffers.setHeaderSize(6*1024);
74          _responseBuffers.setBufferSize(12*1024);
75          _responseBuffers.setHeaderSize(6*1024);
76      }
77  
78      protected void doStart()
79          throws Exception
80      {
81          super.doStart();
82      }
83      
84      /**
85       * @return Returns the headerBufferSize.
86       * @deprecated use {@link #getRequestHeaderSize()} or {@link #getResponseHeaderSize()}
87       */
88      public int getHeaderBufferSize()
89      {
90          return _requestBuffers.getHeaderSize();
91      }
92  
93      public Buffers getRequestBuffers()
94      {
95          return _requestBuffers;
96      }
97      
98      /**
99       * @return Returns the requestBufferSize.
100      */
101     public int getRequestBufferSize()
102     {
103         return _requestBuffers.getBufferSize();
104     }
105     
106     /**
107      * @return Returns the request header size.
108      */
109     public int getRequestHeaderSize()
110     {
111         return _requestBuffers.getHeaderSize();
112     }
113 
114     public Buffers getResponseBuffers()
115     {
116         return _requestBuffers;
117     }
118     
119     /**
120      * @return Returns the responseBufferSize.
121      */
122     public int getResponseBufferSize()
123     {
124         return _responseBuffers.getBufferSize();
125     }
126     
127     /**
128      * @return Returns the response header size.
129      */
130     public int getResponseHeaderSize()
131     {
132         return _responseBuffers.getHeaderSize();
133     }
134 
135     protected abstract Buffer newRequestBuffer(int size);
136 
137     protected abstract Buffer newRequestHeader(int size);
138 
139     protected abstract Buffer newResponseBuffer(int size);
140 
141     protected abstract Buffer newResponseHeader(int size);
142     
143     /* ------------------------------------------------------------ */
144     /**
145      * @param buffer
146      * @return True if the buffer is the correct type for a request header buffer
147      */
148     protected abstract boolean isRequestHeader(Buffer buffer);
149 
150     /* ------------------------------------------------------------ */
151     /**
152      * @param buffer
153      * @return True if the buffer is the correct type for a response header buffer
154      */
155     protected abstract boolean isResponseHeader(Buffer buffer);
156     
157     
158 
159     /**
160      * @param headerBufferSize The headerBufferSize to set.
161      * @deprecated 
162      */
163     public void setHeaderBufferSize( int headerBufferSize )
164     {
165         setRequestHeaderSize(headerBufferSize);
166         setResponseHeaderSize(headerBufferSize);
167     }
168     
169     /**
170      * @param size The requestBufferSize to set.
171      */
172     public void setRequestBufferSize( int size )
173     {
174         if (isStarted())
175           throw new IllegalStateException();
176         _requestBuffers.setBufferSize(size);
177     }
178     /**
179      * @param size 
180      */
181     public void setRequestHeaderSize( int size )
182     {
183         if (isStarted())
184             throw new IllegalStateException();
185         _requestBuffers.setHeaderSize(size);
186     }
187     
188     /**
189      * @param size The response buffer size in bytes.
190      */
191     public void setResponseBufferSize( int size )
192     {
193         if (isStarted())
194           throw new IllegalStateException();
195         _responseBuffers.setBufferSize(size);
196     }
197     /**
198      * @param size 
199      */
200     public void setResponseHeaderSize( int size )
201     {
202         if (isStarted())
203             throw new IllegalStateException();
204         _responseBuffers.setHeaderSize(size);
205     }
206     
207 }