1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
-------------------- CORE --------------------
- reloading: objects loaded with the parent class loader will not be touched.
( faster, fewer problems with non-serializable objects )
- better session plugability
- improved authentication - a bit of performance and more flexibility
(CredentialInterceptor)
- sealed the facade
- refactoring of MessageBytes
- refactoring of AJP1.3 ( Dan Milstein )
AJP1.3 support for Webdav methods ( Keith Wannamaker )
- merged the improved error handling from 3.2 ( Larry )
- refactoring of Cookie handling, faster code, recycle cookies. Proper
implementation of V1 cookies.
- Only one type of Interceptor - remove the separation between Context/Request
Interceptor
- Use introspection to detect the hooks implemented by an interceptor, call
only the interceptors that are implementing the hooks.
- Added handleError hook, refactoring/modularization of error handling - it
is now implemented by a module that can be changed ( see Larry's requirements )
- Added documentation and code to enforce "states" and the order in wich the
hooks are called based on tomcat and context state. For example addContext()
can't be called before tomcat is initialized ( all engineInit done ), etc
- Optional separation of tomcat class loader and webapps classloaders,
similar with Catalina's
- Rewrite of class reloading, the check for expire is no longer done
per/request, but in a background thread. Added DependManager, that allows
checks for all resources, not only classes and works with any class
loader ( including URLClassLoader )
- use of URLClassLoader if JDK1.2 is used ( faster, more secure )
- removal of all deprecated methods and calls
- more documentation
- removal of ServletLoader interface, it's functionality is already provided
in interceptors
- insure org.apache.tomcat.core and facade are layered and remove all
spaghetti calls between layers.
- rewrite of ServletWrapper, separate base ( core ) functionality from the
jsp and servlet-specific.
- removal of ServletConnector, it's functionality can be provided in standard
interceptors. By using normal interceptors a Connector can be better configured
( no more <property name/value /> ), and it can affect all request processing
stages ( to allow future server-based authentication, more performance, etc )
- Move back to the original Request/Response base classes instead of
interfaces.
The interfaces were introduced in an effort to merge with Catalina ( by using
common interfaces), but it's a 2-sided process.
- Removal of FacadeManager - it's not needed as the same functionality can be
provided by Interceptors ( to plug the facade ) and simpler mechanisms to
access to internal and check "trusted" apps.
- consolidation of error messages in tomcat.res, consistent with other
apache projects ( and simpler to maintain )
- Removal of Constants - each object will store it's own constants
( tomcat name/version -> ContextManager,
request attributes -> Request, context attributes -> context,
static file resources -> StaticInterceptor, etc ). This also
prevent future inconsistencies ( most of the Constants are not used
in 3.2 anyway )
- Make the "Buffer" a top level element, remove
BufferedInputStream/BufferedOutputStream. That allow a big increase in performance and allow future improvements by eliminating multiple "copy" and better
reuse of objects.
- Refactoring for all connectors - use more Interceptor features, separate the
tomcat-specific code from the protocol-specific code ( for possible
future reuse )
- Use of MessageBytes for all request components
- major simplification of the overal design - fewer and simpler "contracts"
( Interceptor, 6 core objects ) instead of ( Interceptor, Loader,
Connector, 12 core objects ), real layering ( instead of spaghetti ), almost
all functionality is now in modules ( like Apache !)
- refactoring of session - use Interceptors for full access to all request
stages, keep tomcat-independent code separated and reusable.
-------------------- MODULES --------------------
- ApacheConfig now has optional attibutes to configure various paths
used in auto-generated config files for jserv and mod_jk.
-------------------- UTILS --------------------
- consolidation/refactoring of all tomcat-independent and general-purpose/
reusable code into org.apache.tomcat.util.[log, etc ]
- refactoring for all utils, make sure they are reusable and worth to be
reused :-)
-------------------- BUILD/STARTUP --------------------
- On startup, after the server is initialized, the Ajp12Interceptor will
generate conf/ajp12.id containing it's port and secret ( if any ), to
allow easy stop.
- the unix start scripts now take a "-wait" option ( "tomcat.sh start -wait" )
making the script wait until the server is started. This is good for
automated tests.
- the unix scripts will generate a conf/tomcat.pid file with the pid
of the java process that is put in background. This should be used as
a last resort if normal shutdown fails.
- the -security option is passed and processed in Java. All sandboxing
options are specified using PolicyInterceptor ( including the
policy file, etc ) - the command line is no longer used. This allows
people embeding tomcat the same control and reduces the complexity of
the shell script.
- org.apache.tomcat.startup.Main now builds 3 distinct class loaders: (1)
one to be used only by the servlet container. (2) one to be shared by all
web applications and (3) one that is common to both the above.
- TOMCAT_HOME/lib now sports three subdirectories: apps/, container/ and
common/ in which jar files can be placed that will be automatically loaded
into the correct classloaders. In addition, classes can be made available
to the 'apps' and 'common' classloaders by including them in the classpath
properties "-Dorg.apache.tomcat.apps.classpath" and
"-Dorg.apache.tomcat.common.classpath", respectively.
- generate separate jar files for each component ( utils, core, facade,
modules ) That insures the layers are properly separated, utils can be reused.
- use JDK1.2 Main-Class: and a custom starter - deprecate the shell/bat
scripts and use java to process arguments, guess tomcat home, etc
------------------ CONNECTOR -----------------
- mod_jk for Apache2.0 now works (Henri Gomez)
- no more problem with Apache mod_jk/ajp13 when the tomcat restart (Henri)
- mod_jk code cleanup (Henri, Dan, Keith)
- document MOD_JK, AJP13 (Dan)
-------------------- TODO --------------------
( not yet implemented , but it would be nice to have them )
- Reimplement cookies, make the code reusable ( maybe allow fast sessionId,
lazy evaluation )
- move jasper to a top-level module ( or at least under src/jasper )
- rename shell to bin, etc to conf ( after the files that are not needed
are removed or reorganized )
- the EncodingInterceptor that uses MessageBytes and find the right charset
- Use custom-code for Parameters, Cookies ( faster data strucures, like in
MimeHeaders )
- Merge of all modules -> org.apache.tomcat.modules.[config,server,request,etc]
instead of org.apache.tomcat.context/request
- A new configuration mechanism that deals with virtual hosts, allow simpler
installation and configuration for contexts
- Improve Nacho's per/context interceptors, allow "profiles" ( sets of
interceptors that are shared by multiple contexts )
- removal of helpers - use either util ( for tomcat-independent, reusable
functionality, or Interceptors for tomcat-specific code )
- use JAXP1.1, reopen the debate on binaries checked in
- save auth result in session ( idea from catalina )
- cache pages/fragments
- test mutual auth
- better integration for form login with apache
- Optimize error handling. For example, we can use int IDs for error
messages ( needs enhancements in StringManager )
- Cache the error page handler ( instead of doing a second mapping
for each request that authenticates/redirects/have an error).
- improve the configuration system for Tomcat Standalone and Tomcat+Apache.
- Consistent message handling ( and test with various locales ). Clean up
unused strings, make sure all the messages are localized.
- avoid sending common headers like EngineHeader for every request ( apache)
- Maybe rename ContextManager -> ServletContainer
- Merge HTTP1.1 code from catalina
- Merge JMX code from catalina
- Merge JNDI code from catalina
- Experiment and implement "sendFile" for chunks of static JSP, cache the
static region as byte[] on the server ( integrated mode )
- Add callbacks to mod_jk, integrate authentication ( user Apache's user db)
- Experiment with mixed applications, integrate the session and auth
representation of mod_perl and php
- Implement the profiling web app ( that allows you to get a profile of a
servlet container, how expensive is each API call )
- Expose more internals via /admin ( number of threads, memory, etc)
- Experiment with Apache2.0 config ( and IIS ? ), try to integrate
- Make sure the request parsed by Apache is not parsed again.
- Interceptor == Module == SAF ( will this ever happen ?)
|
