/*
* This file is part of the Echo Web Application Framework (hereinafter "Echo").
* Copyright (C) 2002-2009 NextApp, Inc.
*
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*/
package nextapp.echo2.webcontainer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import nextapp.echo2.app.ApplicationInstance;
import nextapp.echo2.app.Component;
import nextapp.echo2.app.TaskQueueHandle;
import nextapp.echo2.app.update.UpdateManager;
import nextapp.echo2.webcontainer.util.IdTable;
import nextapp.echo2.webrender.Connection;
import nextapp.echo2.webrender.UserInstance;
/**
* Web application container user instance.
*/
public class ContainerInstance extends UserInstance {
/**
* Default asynchronous monitor callback interval (in milliseconds).
*/
private static final int DEFAULT_CALLBACK_INTERVAL = 500;
/**
* Returns the base HTML element id that should be used when rendering the
* specified <code>Component</code>.
*
* @param component the component
* @return the base HTML element id
*/
public static String getElementId(Component component) {
return "c_" + component.getRenderId();
}
/**
* Creates a new Web Application Container instance using the provided
* client <code>Connection</code>. The instance will automatically
* be stored in the relevant <code>HttpSession</code>
*
* @param conn the client/server <code>Connection</code> for which the
* instance is being instantiated
*/
public static void newInstance(Connection conn) {
new ContainerInstance(conn);
}
private ApplicationInstance applicationInstance;
private Map componentToRenderStateMap = new HashMap();
private transient IdTable idTable;
private boolean initialized = false;
private Map initialRequestParameterMap;
private transient Map taskQueueToCallbackIntervalMap;
/**
* Creates a new <code>ContainerInstance</code>.
*
* @param conn the client/server <code>Connection</code> for which the
* instance is being instantiated
* @see #newInstance(nextapp.echo2.webrender.Connection)
*/
private ContainerInstance(Connection conn) {
super(conn);
setServerDelayMessage(DefaultServerDelayMessage.INSTANCE);
initialRequestParameterMap = new HashMap(conn.getRequest().getParameterMap());
}
/**
* Returns the corresponding <code>ApplicationInstance</code>
* for this user instance.
*
* @return the relevant <code>ApplicationInstance</code>
*/
public ApplicationInstance getApplicationInstance() {
return applicationInstance;
}
/**
* Determines the application-specified asynchronous monitoring
* service callback interval.
*
* @return the callback interval, in ms
*/
public int getCallbackInterval() {
if (taskQueueToCallbackIntervalMap == null || taskQueueToCallbackIntervalMap.size() == 0) {
return DEFAULT_CALLBACK_INTERVAL;
}
Iterator it = taskQueueToCallbackIntervalMap.values().iterator();
int returnInterval = Integer.MAX_VALUE;
while (it.hasNext()) {
int interval = ((Integer) it.next()).intValue();
if (interval < returnInterval) {
returnInterval = interval;
}
}
return returnInterval;
}
/**
* Retrieves the <code>Component</code> with the specified element id.
*
* @param elementId the element id, e.g., "c_42323"
* @return the component (e.g., the component whose id is "42323")
*/
public Component getComponentByElementId(String elementId) {
try {
return applicationInstance.getComponentByRenderId(elementId.substring(2));
} catch (IndexOutOfBoundsException ex) {
throw new IllegalArgumentException("Invalid component element id: " + elementId);
}
}
/**
* Retrieves the <code>IdTable</code> used by this
* <code>ContainerInstance</code> to assign weakly-referenced unique
* identifiers to arbitrary objects.
*
* @return the <code>IdTable</code>
*/
public IdTable getIdTable() {
if (idTable == null) {
idTable = new IdTable();
}
return idTable;
}
/**
* Returns an immutable <code>Map</code> containing the HTTP form
* parameters sent on the initial request to the application.
*
* @return the initial request parameter map
*/
public Map getInitialRequestParameterMap() {
return initialRequestParameterMap;
}
/**
* Retrieves the <code>RenderState</code> of the specified
* <code>Component</code>.
*
* @param component the component
* @return the rendering state
*/
public RenderState getRenderState(Component component) {
return (RenderState) componentToRenderStateMap.get(component);
}
/**
* Convenience method to retrieve the application's
* <code>UpdateManager</code>, which is used to synchronize
* client and server states.
* This method is equivalent to invoking
* <code>getApplicationInstance().getUpdateManager()</code>.
*
* @return the <code>UpdateManager</code>
*/
public UpdateManager getUpdateManager() {
return applicationInstance.getUpdateManager();
}
/**
* Initializes the <code>ContainerInstance</code>, creating an instance
* of the target <code>ApplicationInstance</code> and initializing the state
* of the application.
*
* @param conn the relevant <code>Connection</code>
*/
public void init(Connection conn) {
if (initialized) {
throw new IllegalStateException("Attempt to invoke ContainerInstance.init() on initialized instance.");
}
WebContainerServlet servlet = (WebContainerServlet) conn.getServlet();
applicationInstance = servlet.newApplicationInstance();
ContainerContext containerContext = new ContainerContextImpl(this);
applicationInstance.setContextProperty(ContainerContext.CONTEXT_PROPERTY_NAME, containerContext);
try {
ApplicationInstance.setActive(applicationInstance);
applicationInstance.doInit();
} finally {
ApplicationInstance.setActive(null);
}
initialized = true;
}
/**
* Determines if the <code>ContainerInstance</code> has been initialized,
* i.e., whether its <code>init()</code> method has been invoked.
*
* @return true if the <code>ContainerInstance</code> is initialized
*/
boolean isInitialized() {
return initialized;
}
/**
* Removes the <code>RenderState</code> of the specified
* <code>Component</code>.
*
* @param component the component
*/
public void removeRenderState(Component component) {
componentToRenderStateMap.remove(component);
}
/**
* Sets the <code>RenderState</code> of the specified
* <code>Component</code>.
*
* @param component the component
* @param renderState the render state
*/
public void setRenderState(Component component, RenderState renderState) {
componentToRenderStateMap.put(component, renderState);
}
/**
* Sets the interval between asynchronous callbacks from the client to check
* for queued tasks for a given <code>TaskQueue</code>. If multiple
* <code>TaskQueue</code>s are active, the smallest specified interval should
* be used. The default interval is 500ms.
* Application access to this method should be accessed via the
* <code>ContainerContext</code>.
*
* @param taskQueue the <code>TaskQueue</code>
* @param ms the number of milliseconds between asynchronous client
* callbacks
* @see nextapp.echo2.webcontainer.ContainerContext#setTaskQueueCallbackInterval(nextapp.echo2.app.TaskQueueHandle, int)
*/
public void setTaskQueueCallbackInterval(TaskQueueHandle taskQueue, int ms) {
if (taskQueueToCallbackIntervalMap == null) {
taskQueueToCallbackIntervalMap = new WeakHashMap();
}
taskQueueToCallbackIntervalMap.put(taskQueue, new Integer(ms));
}
/**
* @see javax.servlet.http.HttpSessionActivationListener#sessionDidActivate(javax.servlet.http.HttpSessionEvent)
*/
public void sessionDidActivate(HttpSessionEvent e) {
super.sessionDidActivate(e);
if (applicationInstance != null) {
applicationInstance.activate();
}
}
/**
* @see javax.servlet.http.HttpSessionActivationListener#sessionWillPassivate(javax.servlet.http.HttpSessionEvent)
*/
public void sessionWillPassivate(HttpSessionEvent e) {
if (applicationInstance != null) {
applicationInstance.passivate();
}
super.sessionWillPassivate(e);
}
/**
* @see javax.servlet.http.HttpSessionBindingListener#valueUnbound(javax.servlet.http.HttpSessionBindingEvent)
*/
public void valueUnbound(HttpSessionBindingEvent e) {
if (applicationInstance != null) {
applicationInstance.dispose();
}
super.valueUnbound(e);
}
}