ICEpush provides a web-based asynchronous notification mechanism in support of pushing updates from a server-based web application to a client browser connected to that application. The mechanism includes both client and server constituents, and leverages long polling over a blocking connection to deliver notifications asynchronously from the server to the client.
The core mechanism is purely for push notification, and carries only the minimum payload required to achieve it. An integration layer must be implemented around the core to provide payload processing. This integration will be specific to the client and server technologies used in the application's implementation. A number of technology-specific [Integration Bundles] are available for ICEpush.
The mechanism, in it's simplest form, is illustrated below with both block and sequence diagrams.
The core constituents include:
|Push Service||An environment-specific library (Java, .net, PHP, ...) integrated into the web application to manage the blocking connection and listen for notification events. When notifications occur, the Push Service fulfills the blocked notification request.|
Technology-specific integration constituents include:
|Push Business Logic||Framework and/or application specific business logic for pushing updates. This logic must be able to trigger push notifications based on some state change in the application, and then deliver the associated payload when requested.|
In order to achieve true asynchronous notifications from the server to the client using only standard HTTP communications, it is necessary to invert the protocol and use long polling, where a connection is held open in anticipation of a notification event that will complete the request/response cycle over that connection. There are a number of ramifications associated with these long-held connections that must be addressed by the core notification mechanism.
For a browser client viewing a single push-enabled page, two connections are required - one blocking connection for the push notifications, and one non-blocking connection for all other Ajax and user-initiated requests. As you extend beyond this simplest use case to multiple browser tabs open to the same application, or multiple push-enabled applications being viewed from the same browser, it is not feasible to open multiple blocking connections for each of the page views, as this will lead to connection exhaustion at the browse (IE allows only two connections to the same domain). Under these more advanced use cases it is necessary for the core notification mechanism to perform connection sharing to prevent connection exhaustion. For a single web application, connection sharing can be achieve entirely on the client side, but as you move into multi-application and clustered deployments, server-side connection sharing also becomes necessary. ICEpush provides full-featured client-side connection sharing, and basic server-side connection management for single and multi-application deployments.
|For complete server-side connection sharing and clustered deployment support, the commercial ICEpush EE and specifically the Enterprise Push Server (EPS) are required.|
The following use cases are considered:
|Applications||Push Clients/Page||Browser Views||ICEpush||ICEpush EE/EPS|
|Multiple (ie: portlets)||Single|
When multiple push applications are detected in a configuration without an EPS, a single application is elected to host the push connection and all other applications revert to polling on a configurable interval.
Because long-held connections over the Internet can be unreliable, server-side connection heartbeating is used to keep the connection healthy.
Holding HTTP connections open at the server can have performance and scalability ramifications at the server. Typical HTTP processing maintains a thread per connections which can lead to thread exhaustion. Asynchronous request process can alleviate performance problems associated with blocking connections, but ARP mechanisms are typically proprietary and server-specific.
In the Java domain, the Servlet 3.0 specification unifies ARP support, so the Push Service implementation in Java will be able to leverage standards-based ARP APIs.