Author: markt
Date: Tue May 26 21:04:50 2015
New Revision: 1681868
URL: http://svn.apache.org/r1681868
Log:
Update startup description. Written with Tomcat 9 in mind but better than the
old one based on Tomcat 5.
Modified:
tomcat/tc6.0.x/trunk/webapps/docs/architecture/startup/serverStartup.txt
Modified:
tomcat/tc6.0.x/trunk/webapps/docs/architecture/startup/serverStartup.txt
URL:
http://svn.apache.org/viewvc/tomcat/tc6.0.x/trunk/webapps/docs/architecture/startup/serverStartup.txt?rev=1681868&r1=1681867&r2=1681868&view=diff
==============================================================================
--- tomcat/tc6.0.x/trunk/webapps/docs/architecture/startup/serverStartup.txt
(original)
+++ tomcat/tc6.0.x/trunk/webapps/docs/architecture/startup/serverStartup.txt
Tue May 26 21:04:50 2015
@@ -13,126 +13,127 @@
See the License for the specific language governing permissions and
limitations under the License.
-Tomcat 5 Startup Sequence
+Tomcat Startup Sequence
Sequence 1. Start from Command Line
Class: org.apache.catalina.startup.Bootstrap
What it does:
- a) Set up classloaders
- commonLoader (common)-> System Loader
- sharedLoader (shared)-> commonLoader -> System Loader
- catalinaLoader(server) -> commonLoader -> System Loader
- b) Load startup class (reflection)
- org.apache.catalina.startup.Catalina
- setParentClassloader -> sharedLoader
- Thread.contextClassloader -> catalinaLoader
- c) Bootstrap.daemon.init() complete
-
-Sequence 2. Process command line argument (start, startd, stop, stopd)
+ a) Set up classloaders
+ commonLoader (common)-> System Loader
+ sharedLoader (shared)-> commonLoader -> System Loader
+ catalinaLoader(server) -> commonLoader -> System Loader
+ (by default the commonLoader is used for the
+ sharedLoader and the serverLoader)
+ b) Load startup class (reflection)
+ org.apache.catalina.startup.Catalina
+ setParentClassloader -> sharedLoader
+ Thread.contextClassloader -> catalinaLoader
+ c) Bootstrap.daemon.init() complete
+
+Sequence 2. Process command line argument (start, stop)
Class: org.apache.catalina.startup.Bootstrap (assume command->start)
-What it does:
- a) Catalina.setAwait(true);
- b) Catalina.load()
- b1) initDirs() -> set properties like
- catalina.home
- catalina.base == catalina.home (most cases)
- b2) initNaming
-
setProperty(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
-
org.apache.naming.java.javaURLContextFactory ->default)
- b3) createStartDigester()
- Configures a digester for the main server.xml elements
like
- org.apache.catalina.core.StandardServer (can change of
course :)
- org.apache.catalina.deploy.NamingResources
- Stores naming resources in the J2EE JNDI tree
- org.apache.catalina.LifecycleListener
- implements events for start/stop of major
components
- org.apache.catalina.core.StandardService
- The single entry for a set of connectors,
- so that a container can listen to multiple
connectors
- ie, single entry
- org.apache.coyote.tomcat5.CoyoteConnector
- Connectors to listen for incoming requests only
- It also adds the following rulesets to the digester
- NamingRuleSet
- EngineRuleSet
- HostRuleSet
- ContextRuleSet
- b4) Load the server.xml and parse it using the digester
- Parsing the server.xml using the digester is an automatic
- XML-object mapping tool, that will create the objects
defined in server.xml
- Startup of the actual container has not started yet.
- b5) Assigns System.out and System.err to the SystemLogHandler
class
- b6) Calls initialize on all components, this makes each object
register itself with the
- JMX agent.
- During the process call the Connectors also initialize the
adapters.
- The adapters are the components that do the request
pre-processing.
- Typical adapters are HTTP1.1 (default if no protocol is
specified,
- org.apache.coyote.http11.Http11Protocol)
- AJP1.3 for mod_jk etc.
-
- c) Catalina.start()
- c1) Starts the NamingContext and binds all JNDI references into
it
- c2) Starts the services under <Server> which are:
- StandardService -> starts Engine (ContainerBase
->Logger,Loader,Realm,Cluster etc)
- c3) StandardHost (started by the service)
- Configures a ErrorReportValvem to do proper
HTML output for different HTTP
- errors codes
- Starts the Valves in the pipeline (at least the
ErrorReportValve)
- Configures the StandardHostValve,
- this valves ties the Webapp Class
loader to the thread context
- it also finds the session for the
request
- and invokes the context pipeline
- Starts the HostConfig component
- This component deploys all the webapps
- (webapps &
conf/Catalina/localhost/*.xml)
- Webapps are installed using the
deployer (StandardHostDeployer)
- The deployer will create a Digester for
your context, this digester
- will then invoke ContextConfig.start()
- The ContextConfig.start() will
process the default web.xml (conf/web.xml)
- and then process the
applications web.xml (WEB-INF/web.xml)
-
- c4) During the lifetime of the container (StandardEngine) there
is a background thread that
- keeps checking if the context has changed. If a context
changes (timestamp of war file,
- context xml file, web.xml) then a reload is issued
(stop/remove/deploy/start)
-
- d) Tomcat receives a request on an HTTP port
- d1) The request is received by a separate thread which is waiting
in the PoolTcpEndPoint
- class. It is waiting for a request in a regular
ServerSocket.accept() method.
- When a request is received, this thread wakes up.
- d2) The PoolTcpEndPoint assigns the a TcpConnection to handle the
request.
- It also supplies a JMX object name to the catalina container
(not used I believe)
- d3) The processor to handle the request in this case is Coyote
Http11Processor,
- and the process method is invoked.
- This same processor is also continuing to check the input
stream of the socket
- until the keep alive point is reached or the connection is
disconnected.
- d4) The HTTP request is parsed using an internal buffer class
(Coyote Http11 Internal Buffer)
- The buffer class parses the request line, the headers, etc and
store the result in a
- Coyote request (not an HTTP request) This request contains all
the HTTP info, such
- as servername, port, scheme, etc.
- d5) The processor contains a reference to an Adapter, in this case
it is the
- Coyote Tomcat 5 Adapter. Once the request has been parsed, the
Http11 processor
- invokes service() on the adapter. In the service method, the
Request contains a
- CoyoteRequest and CoyoteRespons (null for the first time)
- The CoyoteRequest(Response) implements HttpRequest(Response)
and HttpServletRequest(Response)
- The adapter parses and associates everything with the request,
cookies, the context through a
- Mapper, etc
- d6) When the parsing is finished, the CoyoteAdapter invokes its
container (StandardEngine)
- and invokes the invoke(request,response) method.
- This initiates the HTTP request into the Catalina container
starting at the engine level
- d7) The StandardEngine.invoke() simply invokes the container
pipeline.invoke()
- d8) By default the engine only has one valve the
StandardEngineValve, this valve simply
- invokes the invoke() method on the Host pipeline
(StandardHost.getPipeLine())
- d9) the StandardHost has two valves by default, the
StandardHostValve and the ErrorReportValve
- d10) The standard host valve associates the correct class loader
with the current thread
- It also retrieves the Manager and the session associated with
the request (if there is one)
- If there is a session access() is called to keep the session
alive
- d11) After that the StandardHostValve invokes the pipeline on the
context associated
- with the request.
- d12) The first valve that gets invoked by the Context pipeline is
the FormAuthenticator
- valve. Then the StandardContextValve gets invoke.
- The StandardContextValve invokes any context listeners
associated with the context.
- Next it invokes the pipeline on the Wrapper component
(StandardWrapperValve)
- d13) During the invocation of the StandardWrapperValve, the JSP
wrapper (Jasper) gets invoked
- This results in the actual compilation of the JSP.
- And then invokes the actual servlet.
- e) Invocation of the servlet class
+What it does:
+ a) Catalina.setAwait(true);
+ b) Catalina.load()
+ b1) initDirs() -> set properties like
+ catalina.home
+ catalina.base == catalina.home (most cases)
+ b2) initNaming
+ setProperty(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
+ org.apache.naming.java.javaURLContextFactory ->default)
+ b3) createStartDigester()
+ Configures a digester for the main server.xml elements like
+ org.apache.catalina.core.StandardServer (can change of course :)
+ org.apache.catalina.deploy.NamingResources
+ Stores naming resources in the J2EE JNDI tree
+ org.apache.catalina.LifecycleListener
+ implements events for start/stop of major components
+ org.apache.catalina.core.StandardService
+ The single entry for a set of connectors,
+ so that a container can listen to multiple connectors
+ ie, single entry
+ org.apache.catalina.Connector
+ Connectors to listen for incoming requests only
+ It also adds the following rulesets to the digester
+ NamingRuleSet
+ EngineRuleSet
+ HostRuleSet
+ ContextRuleSet
+ b4) Load the server.xml and parse it using the digester
+ Parsing the server.xml using the digester is an automatic
+ XML-object mapping tool, that will create the objects defined in
server.xml
+ Startup of the actual container has not started yet.
+ b5) Assigns System.out and System.err to the SystemLogHandler class
+ b6) Calls initialize on all components, this makes each object
register itself with the
+ JMX agent.
+ During the process call the Connectors also initialize the
adapters.
+ The adapters are the components that do the request pre-processing.
+ Typical adapters are HTTP1.1 (default if no protocol is specified,
+ org.apache.coyote.http11.Http11Protocol)
+ AJP1.3 for mod_jk etc.
+
+ c) Catalina.start()
+ c1) Starts the NamingContext and binds all JNDI references into it
+ c2) Starts the services under <Server> which are:
+ StandardService -> starts Engine (ContainerBase -> Realm,Cluster
etc)
+ c3) StandardHost (started by the service)
+ Configures a ErrorReportValvem to do proper HTML output for
different HTTP
+ errors codes
+ Starts the Valves in the pipeline (at least the
ErrorReportValve)
+ Configures the StandardHostValve,
+ this valves ties the Webapp Class loader to the thread
context
+ it also finds the session for the request
+ and invokes the context pipeline
+ Starts the HostConfig component
+ This component deploys all the webapps
+ (webapps & conf/Catalina/localhost/*.xml)
+ HostConfig will create a Digester for your context, this
digester
+ will then invoke ContextConfig.start()
+ The ContextConfig.start() will process the default
web.xml (conf/web.xml)
+ and then process the applications web.xml
(WEB-INF/web.xml)
+
+ c4) During the lifetime of the container (StandardEngine) there is a
background thread that
+ keeps checking if the context has changed. If a context changes
(timestamp of war file,
+ context xml file, web.xml) then a reload is issued
(stop/remove/deploy/start)
+
+ d) Tomcat receives a request on an HTTP port
+ d1) The request is received by a separate thread which is waiting in
the ThreadPoolExecutor
+ class. It is waiting for a request in a regular
ServerSocket.accept() method.
+ When a request is received, this thread wakes up.
+ d2) The ThreadPoolExecutor assigns the a TaskThread to handle the
request.
+ It also supplies a JMX object name to the catalina container (not
used I believe)
+ d3) The processor to handle the request in this case is Coyote
Http11Processor,
+ and the process method is invoked.
+ This same processor is also continuing to check the input stream
of the socket
+ until the keep alive point is reached or the connection is
disconnected.
+ d4) The HTTP request is parsed using an internal buffer class
(Http11InputBuffer)
+ The buffer class parses the request line, the headers, etc and
store the result in a
+ Coyote request (not an HTTP request) This request contains all the
HTTP info, such
+ as servername, port, scheme, etc.
+ d5) The processor contains a reference to an Adapter, in this case it
is the
+ CoyoteAdapter. Once the request has been parsed, the
Http11Processor
+ invokes service() on the adapter. In the service method, the
Request contains a
+ CoyoteRequest and CoyoteResponse (null for the first time)
+ The CoyoteRequest(Response) implements HttpRequest(Response) and
HttpServletRequest(Response)
+ The adapter parses and associates everything with the request,
cookies, the context through a
+ Mapper, etc
+ d6) When the parsing is finished, the CoyoteAdapter invokes its
container (StandardEngine)
+ and invokes the invoke(request,response) method.
+ This initiates the HTTP request into the Catalina container
starting at the engine level
+ d7) The StandardEngine.invoke() simply invokes the container
pipeline.invoke()
+ d8) By default the engine only has one valve the StandardEngineValve,
this valve simply
+ invokes the invoke() method on the Host pipeline
(StandardHost.getPipeLine())
+ d9) the StandardHost has two valves by default, the StandardHostValve
and the ErrorReportValve
+ d10) The standard host valve associates the correct class loader with
the current thread
+ It also retrieves the Manager and the session associated with the
request (if there is one)
+ If there is a session access() is called to keep the session alive
+ d11) After that the StandardHostValve invokes the pipeline on the
context associated
+ with the request.
+ d12) The first valve that gets invoked by the Context pipeline is the
FormAuthenticator
+ valve. Then the StandardContextValve gets invoke.
+ The StandardContextValve invokes any context listeners associated
with the context.
+ Next it invokes the pipeline on the Wrapper component
(StandardWrapperValve)
+ d13) During the invocation of the StandardWrapperValve, the JSP
wrapper (Jasper) gets invoked
+ This results in the actual compilation of the JSP.
+ And then invokes the actual servlet.
+ e) Invocation of the servlet class
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org
