A general discussion of concurrent calls to Seam components can be
found in Section 4.1.10, “Concurrency model”. Here we will discuss
the most common situation in which you will encounter concurrency
— accessing conversational components from AJAX requests.
We're going to discuss the options that a Ajax client library should
provide to control events originating at the client — and we'll
look at the options RichFaces gives you.
Conversational components don't allow real concurrent access therefore
Seam queues each request to process them serially. This allows each
request to be executed in a deterministic fashion. However, a simple
queue isn't that great — firstly, if a method is, for some
reason, taking a very long time to complete, running it over and over
again whenever the client generates a request is bad idea (potential
for Denial of Service attacks), and, secondly, AJAX is often to used
to provide a quick status update to the user, so continuing to run the
action after a long time isn't useful.
Therefore, when you are working inside a long running conversation,
Seam queues the action event for a period of time (the concurrent
request timeout); if it can't process the event in time, it creates a
temporary conversation and prints out a message to the user to let them
know what's going on. It's therefore very important not to flood the
server with AJAX events!
We can set a sensible default for the concurrent request timeout (in
ms) in components.xml:
<core:manager concurrent-request-timeout="500" />
We can also fine tune the concurrent request timeout on a page-by-page
basis:
<page view-id="/book.xhtml"
conversation-required="true"
login-required="true"
concurrent-request-timeout="2000" />
So far we've discussed AJAX requests which appear serial to the user -
the client tells the server that an event has occur, and then rerenders
part of the page based on the result. This approach is great when the
AJAX request is lightweight (the methods called are simple e.g.
calculating the sum of a column of numbers). But what if we need to do
a complex computation thats going to take a minute?
For heavy computation we should use a poll based approach — the
client sends an AJAX request to the server, which causes action to be
executed asynchronously on the server (the response to the client is
immediate) and the client then polls the server for updates. This is
good approach when you have a long-running action for which it is
important that every action executes (you don't want some to timeout).