# tomcat-users mailing list archives

##### Site index · List index
Message view
Top
From "Reich, Matthias" <matthias.re...@siemens-enterprise.com>
Subject RE: Connection is closed when CometEvent.close is called during an event
Date Tue, 15 Jun 2010 08:12:41 GMT
Konstantin Kolinko wrote:
> 2010/6/11 Reich, Matthias <matthias.reich@siemens-enterprise.com>:
> >
> > The concept of long poll is e.g. described in
> >
> http://www.javaworld.com/javaworld/jw-03-2008/jw-03-asynchhttp
.html?page=6
> >
> > The sequence of events in my situation is as follows:
> > - a poll request is received by the server
> > - the CoyoteAdapter.service method is called and in turn
> >  invokes the servlet's event method with a BEGIN event
> > - request.isComet() is still true when the control returns
> >  to the CoyoteAdapter.service method
> > - some other thread writes a response and closes the Writer
> >  of the response
> > - the CoyoteAdapter.event method is called and in turn
> >  invokes the servlet's event method with an END event
> > - the servlet calls event.close()
> > - when the control returns to the CoyoteAdapter.event method
> >  we have exactly this situation:
> >  response.isClosed() && !request.isComet() &&
> status==SocketStatus.OPEN
> > - thus, if the error flag is set in this situation,
> >  the connection will be closed, and a new connection must be opened
> >  by the browser for the subsequent poll request
> >
> > According to the above sequence I would expect that the connection
> > is always closed if request.isComet() is still true when control
> > returns to the CoyoteAdapter.service method after processing
> > the BEGIN event -  no matter how long it takes from then
> > until the response is written.
> > Surprisingly, I did not always observe this.
> >
> > Anyway, if the error flag is not set in this situation,
> > the connection is kept open.
> >
> >
> >
> > ---
svn001.tmp.java       Do Jun 10 22:22:20 2010
> > +++
> D:\tomcat\TOMCAT_6_0_26\java\org\apache\catalina\connector\Coy
oteAdapter.java       Mo Jun  7 17:30:23 2010
> > @@ -215,7 +215,9 @@
> >                         //CometEvent.close was called
> during an event.
> >
> request.getEvent().setEventType(CometEvent.EventType.END);
> >                         request.getEvent().setEventSubType(null);
> > -                        error = true;
> > +                        // don't set the error flag -
> otherwise the socket will be closed
> > +                        // whenever CometEvent.close is
> called during the event
> > +                        // error = true;
> >
> connector.getContainer().getPipeline().getFirst().event(reques
> t, response, request.getEvent());
> >                     }
> >                     res.action(ActionCode.ACTION_COMET_END, null);
> >
>
> Now I understand. Thank you.
>
> I would say that you are trying to combine Comet and Keep-Alive.

Well, it actually was combined (maybe unintentionally) in 6.0.18.
(I retested an older version of our application which uses 6.0.18
and didn't observe that connections were closed in similar situations.)

Since 6.0.20, the connections are closed upon event.close(),
but it took me some time to get aware of this because when the
subsequent request fails due to the close, the browsers
silently retry that request.

>
> In comet to send a portion of data (a response), you do
> writer.flush(). It sends the data over the wire. Doing event.close()
> terminates comet request processing.
>
> If it were possible not to close the connection, it were possible to
> alternate comet and non-comet processing of subsequent requests over
> the same connection, and to process different requests by different
> servlets.
>
> > - some other thread writes a response and closes the Writer
> >  of the response
>
> Response object is not thread safe. You must write your response in
> event) while you are processing that event.
>
> Otherwise, any random result might happen.
>

Doesn't the sample code on the documentation page include async
writes as well? When it gets a READ event from one connection
it writes to all open connetions.
With respect to all other connections, this is an async write.

In a long poll scenario, closing the Writer seems to be
the only way to trigger a further event (i.e. an END event)
after the BEGIN event.

>
> BTW, for reference:
> There exists the following documentation page,
> http://tomcat.apache.org/tomcat-6.0-doc/aio.html#CometEvent
> and sample code in
> webapps/examples/WEB-INF/classes/chat/ChatServlet.java
> plus some helper JSPs.
>
> The sample is callable as
> http://localost:8080/examples/jsp/chat/chat.jsp  in Tomcat
> 6.0.26 and earlier
> http://localost:8080/examples/jsp/chat/index.jsp  in Tomcat 7 and in
> Tomcat 6.0.27 and later
>
>
> Regarding Comet + Keep-Alive, if it does not work, it is worth filing
> an enhancement request against Tomcat 7.   It would be easier if there
> were some sample code or better a test case.  This new use case has to
> be tested.

I'll try to find the time to prepare something. In the repository
(6.0.26) I have not detected any Comet related test cases. Are there
any test cases you could recommend as an example of how I should
organize it?
What is the best way to deliver the code to you?

>
> The patch you proposing looks promising, but as of now I am
> not sure that
>
> a) both cases when that branch is called are equivalent,
> I mean (response.isClosed()) vs. (!request.isComet()) whether in both
> cases we can go without closing the socket
> Calling CometEventImpl.close() will set both conditions to true.
> I think that response.isClosed() when isComet() == true will mean an
> error and needs closing the socket. Need to think more about it.
>

I think you are right.
If the response is already closed before the container is invoked,
the servlet receives an END event and must call event.close().
If it doesn't, it is an error.

However, the following CAN happen:
- the servlet processes a READ event and therefore
does not call event.close()
- then the response is closed by another thread
- then control returns to CoyoteAdpater.event
- now we have response.isClosed() when isComet() == true

This can only happen in the streaming case, as it requires a
READ event, and even if it is not really an error, I think
it is acceptable to close the socket in this situation.

The servlet programmer knows if the servlet implements
long poll or streaming.
So, maybe the servlet should be enabled to declare
that the connection shall be kept open, e.g. via an
Existing code that relies on the socket close would not be
broken if CometEvent.close() would behave like
CometEvent.close(false).

Such an interface extension would also have the charm
of making explicit that closing an event does not only affect
the associated request but also the connection.

> b) how the socket will be processed further and be returned to the
> poller. There are non-comet vs. comet pollers. There are some
> keepAlive settings (like "maxKeepAliveRequests") and those have to be
> respected.
>

For long poll I want to keep the polling connection open
as long as possible. Therefore I am using maxKeepAliveRequests = -1.

Best regards,
Matthias Reich

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@tomcat.apache.org