reiern70 opened a new issue, #1942:
URL: https://github.com/apache/wicket/issues/1942
**Affects:** 11.0.0 and current master; the same code in 10.x.
**Component:** wicket-core, `wicket-ajax.js` (`Wicket.Ajax.ajax`,
`Wicket.Ajax.Call#ajax`, `Wicket.Channel`, `Wicket.Throttler`),
`IAjaxCallListener`; wicket-extensions, `PageVeilBehavior`
## What happens
A script cannot follow an Ajax call from the moment it is asked for to the
moment it ends, because some of the call's life is never published:
- `/ajax/call/init` is published only by the handlers `Wicket.Ajax.ajax`
binds to events, before throttling. A call made with `Wicket.Ajax.get/post` or
`new Wicket.Ajax.Call().ajax(attrs)` publishes nothing until `doAjax` runs.
- `Wicket.Ajax.Call#ajax` hands the call to its channel. When the channel is
busy, the call waits in its queue (`s`), replaces the calls waiting there
(`d`), or is ignored (`a`). Nothing is published for any of these.
- `/ajax/call/before` through `/ajax/call/done` are published from `doAjax`,
which runs only once the channel is free.
- Some calls never run, and publish nothing at all, not even
`/ajax/call/done`:
- a call dropped from a `d` channel's queue;
- a call ignored by an `a` channel;
- a throttled call replaced by a later one (`Wicket.Throttler#throttle`,
`entry.setFunc(func)`).
A call stopped by its precondition does publish `done`.
So `init` misses calls, and is not always followed by `done`. `beforeSend`
comes after the call has waited in the queue.
## Why it matters
The page veil of `PageVeilBehavior` (#1631) goes up at
`/ajax/call/beforeSend`. Suppose a request that is not veiled is running: a
filter, a timer, or a call with `wicket_nb`. A click on a button then waits in
the channel's queue with no veil over the page, and a second click waits behind
it. Once the channel is free, both run, and the action runs twice. That is the
case the veil is there for.
Raising the veil at `/ajax/call/init` instead does not work either. After a
throttled or dropped call it stays up for good, since no topic tells it the
call is gone. The same holds for any busy indicator, or a guard against double
submits, written on the global topics.
## Proposal
Two topics, with their handlers in `IAjaxCallListener` and
`AjaxCallListener` like the other topics:
- `/ajax/call/queued` (`Wicket.Event.Topic.AJAX_CALL_QUEUED`): published
when the channel makes the call wait behind a running one. The call's
attributes and the channel's name are passed with it. The handler is
`getQueuedHandler(Component)` / `onQueued(...)`.
- `/ajax/call/dropped` (`Wicket.Event.Topic.AJAX_CALL_DROPPED`): published
when a call will never run, for any of these reasons:
- removed from a `d` channel's queue;
- ignored by an `a` channel;
- replaced in the throttler.
The dropped call's attributes and the reason are passed with it. The
handler is `getDroppedHandler(Component)` / `onDropped(...)`.
The guarantee that comes with them: every call that publishes `init` or
`queued` ends with exactly one `done` or `dropped`.
`PageVeilBehavior` could then raise its veil at `init` or `queued`, for the
calls not opted out, and lower it at `done` or `dropped`. A click waiting
behind another request is then veiled, and so is the click that would queue
behind it.
## Workaround
Today the only way is to wrap `Wicket.Channel.prototype.schedule` and
`Wicket.Throttler.prototype.throttle`, which are internal and may change.
Found while working on reiern70/advanced-widgets#141.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]