| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.myfaces.extensions.scripting.api; |
| |
| import org.apache.myfaces.config.RuntimeConfig; |
| import org.apache.myfaces.config.annotation.LifecycleProvider; |
| import org.apache.myfaces.config.annotation.LifecycleProviderFactory; |
| import org.apache.myfaces.config.element.ManagedBean; |
| import org.apache.myfaces.config.element.ManagedProperty; |
| import org.apache.myfaces.extensions.scripting.core.util.ReflectUtil; |
| import org.apache.myfaces.extensions.scripting.core.util.WeavingContext; |
| import org.apache.myfaces.extensions.scripting.monitor.ClassResource; |
| import org.apache.myfaces.extensions.scripting.monitor.RefreshContext; |
| import org.apache.myfaces.extensions.scripting.monitor.RefreshAttribute; |
| import org.apache.myfaces.util.ContainerUtils; |
| |
| import javax.el.ELContext; |
| import javax.el.ExpressionFactory; |
| import javax.faces.context.FacesContext; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.*; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| /** |
| * Bean handler implementation |
| * which encapsulates the myfaces specific parts |
| * of the bean processing |
| */ |
| public class MyFacesBeanHandler implements BeanHandler { |
| |
| final Logger _logger = Logger.getLogger(MyFacesBeanHandler.class.getName()); |
| |
| /** |
| * scripting engine for this bean handler |
| */ |
| int _scriptingEngine; |
| |
| /** |
| * constructor |
| * |
| * @param scriptingEngine the scripting engine the bean handler |
| * currently has to attach to for its |
| * operations |
| */ |
| public MyFacesBeanHandler(int scriptingEngine) { |
| this._scriptingEngine = scriptingEngine; |
| } |
| |
| /** |
| * scans all bean dependencies according to |
| * their IoC information stored by the runtime |
| * (in our case the MyFaces runtime confing) |
| * and adds those into our backward referencing dependency map |
| * to add further dependency information on IoC level |
| * (we can have IoC dependencies which are bound by object |
| * types, this is a corner case but it still can happen) |
| */ |
| public void scanDependencies() { |
| |
| } |
| |
| /** |
| * scans the dependencies on el level |
| * Not working out for now |
| */ |
| /* public void scanElDependencies() { |
| Map<String, ManagedBean> mbeans = RuntimeConfig.getCurrentInstance(FacesContext.getCurrentInstance().getExternalContext()).getManagedBeans(); |
| for(Map.Entry<String, ManagedBean> entry: mbeans.entrySet()) { |
| Object bean = entry.getValue(); |
| if(bean instanceof org.apache.myfaces.config.impl.digester.elements.ManagedBean) { |
| org.apache.myfaces.config.impl.digester.elements.ManagedBean workBean = (org.apache.myfaces.config.impl.digester.elements.ManagedBean) bean; |
| |
| Object props = ReflectUtil.executeMethod(workBean,"getManagedProperties"); |
| if(props instanceof Iterator) { |
| //myfaces 1.2 |
| } else { |
| for(ManagedProperty prop: ((Collection<ManagedProperty>) props)) { |
| ExpressionFactory expFactory = FacesContext.getCurrentInstance().getApplication().getExpressionFactory(); |
| ELContext elContext = FacesContext.getCurrentInstance().getELContext(); |
| expFactory.coerceToType("#{myFactory['booga']}"); |
| //if(ContainerUtils.isValueReference((String) prop.getV)) |
| elContext.getELResolver().getType(elContext,"myFactory","booga"); |
| } |
| } |
| |
| |
| } |
| //Iterator<ManagedProperty> it = bean.getManagedProperties(); |
| //we rescan all managed props to cover pure object |
| //references as well as class references |
| //while(it.hasNext()) { |
| // ManagedProperty prop = it.next(); |
| //} |
| } |
| } */ |
| |
| /** |
| * Refreshes all managed beans |
| * session, and personal scoped ones |
| * <p/> |
| * personal scoped beans are beans which |
| * have either |
| * <li> session scope </li> |
| * <li> page scope </li> |
| * <li> custom scope </li> |
| */ |
| public void refreshAllManagedBeans() { |
| if (FacesContext.getCurrentInstance() == null) { |
| return;//no npe allowed |
| } |
| |
| Set<String> tainted = getTaintedClasses(); |
| |
| //scanElDependencies(); |
| |
| if (tainted.size() > 0) { |
| //We now have to check if the tainted classes belong to the managed beans |
| Set<String> managedBeanClasses = new HashSet<String>(); |
| |
| Map<String, ManagedBean> mbeans = RuntimeConfig.getCurrentInstance(FacesContext.getCurrentInstance().getExternalContext()).getManagedBeans(); |
| Map<String, ManagedBean> mbeansSnapshotView; |
| |
| synchronized (RefreshContext.BEAN_SYNC_MONITOR) { |
| mbeansSnapshotView = makeSnapshot(mbeans); |
| } |
| for (Map.Entry<String, ManagedBean> entry : mbeansSnapshotView.entrySet()) { |
| managedBeanClasses.add(entry.getValue().getManagedBeanClassName()); |
| } |
| |
| boolean managedBeanTainted = isAnyManagedBeanTainted(tainted, managedBeanClasses); |
| markPersonalScopeRefreshRecommended(); |
| getLog().info("[EXT-SCRIPTING] Tainting all beans to avoid classcast exceptions"); |
| if (managedBeanTainted) { |
| globalManagedBeanRefresh(mbeansSnapshotView); |
| //personalScopeRefresh(); |
| } |
| } |
| } |
| |
| /** |
| * Exposed personal scope refresh |
| */ |
| public void personalScopeRefresh() { |
| //shortcut to avoid heavier operations in the beginning |
| long globalBeanRefreshTimeout = WeavingContext.getRefreshContext().getPersonalScopedBeanRefresh(); |
| if (globalBeanRefreshTimeout == -1l) return; |
| |
| Map sessionMap = FacesContext.getCurrentInstance().getExternalContext().getSessionMap(); |
| Long timeOut = (Long) sessionMap.get(ScriptingConst.SESS_BEAN_REFRESH_TIMER); |
| if (timeOut == null || timeOut <= globalBeanRefreshTimeout) { |
| refreshPersonalScopedBeans(); |
| } |
| } |
| |
| /** |
| * removes all bean references which have been tainted |
| * (note for now we remove all dynamic references until we |
| * get a more sophisticated handling of managed beans) |
| * |
| * @param workCopy the managed beam snapshot view |
| */ |
| private void globalManagedBeanRefresh(Map<String, ManagedBean> workCopy) { |
| Set<String> tainted = getTaintedClasses(); |
| |
| for (Map.Entry<String, ManagedBean> entry : workCopy.entrySet()) { |
| Class managedBeanClass = entry.getValue().getManagedBeanClass(); |
| if (hasToBeRefreshed(tainted, managedBeanClass)) { |
| //managed bean class found we drop the class from our session |
| removeBeanReferences(entry.getValue()); |
| } |
| //one bean tainted we have to taint all dynamic beans otherwise we will get classcast |
| //exceptions |
| /*getLog().info("[EXT-SCRIPTING] Tainting "); |
| RefreshAttribute metaData = WeavingContext.getFileChangedDaemon().getClassMap().get(managedBeanClass.getName()); |
| if (metaData != null) { |
| metaData.requestRefresh(); |
| }*/ |
| } |
| } |
| |
| /** |
| * determines whether any bean in our managed bean list |
| * is tainted or not |
| * |
| * @param tainted a list of classes which are tainted in this iteration |
| * @param managedBeanClasses a ist of classes which are our managed beans |
| * @return true if one of the beans is tainted |
| */ |
| private boolean isAnyManagedBeanTainted(Set<String> tainted, Set<String> managedBeanClasses) { |
| boolean managedBeanTainted = false; |
| for (String taintedClass : tainted) { |
| if (managedBeanClasses.contains(taintedClass)) { |
| managedBeanTainted = true; |
| break; |
| } |
| } |
| return managedBeanTainted; |
| } |
| |
| /** |
| * helper which returns all tainted classes |
| * |
| * @return the tainted classes |
| */ |
| private Set<String> getTaintedClasses() { |
| Set<String> tainted = new HashSet<String>(); |
| |
| for (Map.Entry<String, ClassResource> it : WeavingContext.getFileChangedDaemon().getClassMap().entrySet()) { |
| if (it.getValue().getScriptingEngine() == getScriptingEngine() && it.getValue().getRefreshAttribute().requiresRefresh()) { |
| tainted.add(it.getKey()); |
| } |
| } |
| return tainted; |
| } |
| |
| /** |
| * refreshes all personal scoped beans (aka beans which |
| * have an assumed lifecycle <= session) |
| * <p/> |
| * This is needed for multiuser purposes because if one user alters some beans |
| * other users have to drop their non application scoped beans as well! |
| */ |
| private void refreshPersonalScopedBeans() { |
| //the refreshing is only allowed if no compile is in progress |
| //and vice versa |
| Map sessionMap = FacesContext.getCurrentInstance().getExternalContext().getSessionMap(); |
| Long taintingPeriod = (Long) sessionMap.get(ScriptingConst.SESS_BEAN_REFRESH_TIMER); |
| if (taintingPeriod == null) { |
| taintingPeriod = -1l; |
| } |
| Set<String> taintedInTime = WeavingContext.getRefreshContext().getTaintHistoryClasses(taintingPeriod); |
| |
| synchronized (RefreshContext.BEAN_SYNC_MONITOR) { |
| Map<String, ManagedBean> mbeans = RuntimeConfig.getCurrentInstance(FacesContext.getCurrentInstance().getExternalContext()).getManagedBeans(); |
| //the map is immutable but in between scanning might change it so we make a full copy of the map |
| |
| //We can synchronized the refresh, but if someone alters |
| //the bean map from outside we still get race conditions |
| //But for most cases this mutex should be enough |
| Map<String, ManagedBean> mbeansSnapshotView = makeSnapshot(mbeans); |
| |
| for (Map.Entry<String, ManagedBean> entry : mbeansSnapshotView.entrySet()) { |
| Class managedBeanClass = entry.getValue().getManagedBeanClass(); |
| if (hasToBeRefreshed(taintedInTime, managedBeanClass)) { |
| FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove(entry.getValue().getManagedBeanName()); |
| removeCustomScopedBean(entry.getValue()); |
| } |
| } |
| updateBeanRefreshTime(); |
| } |
| } |
| |
| /** |
| * removes the references from out static scope |
| * for jsf2 we probably have some kind of notification mechanism |
| * which notifies custom scopes |
| * |
| * @param bean the managed bean which all references have to be removed from |
| */ |
| |
| private void removeBeanReferences(ManagedBean bean) { |
| if (getLog().isLoggable(Level.FINE)) { |
| getLog().log(Level.FINE, "[EXT-SCRIPTING] JavaScriptingWeaver.removeBeanReferences({0})", bean.getManagedBeanName()); |
| } |
| FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove(bean.getManagedBeanName()); |
| FacesContext.getCurrentInstance().getExternalContext().getApplicationMap().remove(bean.getManagedBeanName()); |
| removeCustomScopedBean(bean); |
| } |
| |
| /** |
| * @return the log for this class |
| */ |
| protected Logger getLog() { |
| return Logger.getLogger(this.getClass().getName()); |
| } |
| |
| /** |
| * jsf2 helper to remove custom scoped beans |
| * |
| * @param bean the managed bean which has to be removed from the custom scope from |
| */ |
| private void removeCustomScopedBean(ManagedBean bean) { |
| Object scopeImpl = FacesContext.getCurrentInstance().getExternalContext().getApplicationMap().get(bean.getManagedBeanScope()); |
| if (scopeImpl == null) return; //scope not implemented |
| //we now have to revert to introspection here because scopes are a pure jsf2 construct |
| //so we use a messaging pattern here to cope with it |
| |
| Object beanInstance = ReflectUtil.executeMethod(scopeImpl, "get", bean.getManagedBeanName()); |
| LifecycleProvider lifecycleProvider = |
| LifecycleProviderFactory.getLifecycleProviderFactory().getLifecycleProvider(FacesContext.getCurrentInstance().getExternalContext()); |
| try { |
| lifecycleProvider.destroyInstance(beanInstance); |
| } catch (IllegalAccessException e) { |
| _logger.log(Level.WARNING, "removeCustomScopedBean():", e); |
| } catch (InvocationTargetException e) { |
| _logger.log(Level.WARNING, "removeCustomScopedBean():", e); |
| } |
| } |
| |
| /** |
| * MyFaces 2.0 keeps an immutable map over the session |
| * and request scoped beans |
| * if we alter that during our loop we get a concurrent modification exception |
| * taking a snapshot in time fixes that |
| * |
| * @param mbeans the internal managed bean map which has to be investigated |
| * @return a map with the class name as key and the managed bean info |
| * as value of the current state of the internal runtime config bean map |
| */ |
| private Map<String, ManagedBean> makeSnapshot(Map<String, ManagedBean> mbeans) { |
| Map<String, ManagedBean> workCopy; |
| |
| workCopy = new HashMap<String, ManagedBean>(mbeans.size()); |
| for (Map.Entry<String, ManagedBean> entry : mbeans.entrySet()) { |
| workCopy.put(entry.getKey(), entry.getValue()); |
| } |
| |
| return workCopy; |
| } |
| |
| /** |
| * updates the internal timer |
| * for our personal scoped beans so that |
| * we dont get updates on beans we have refreshed already |
| */ |
| private void updateBeanRefreshTime() { |
| long sessionRefreshTime = System.currentTimeMillis(); |
| FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put(ScriptingConst.SESS_BEAN_REFRESH_TIMER, sessionRefreshTime); |
| } |
| |
| /** |
| * sets the internal timer for other processes |
| * to update their beans as well |
| */ |
| private void markPersonalScopeRefreshRecommended() { |
| long sessionRefreshTime = System.currentTimeMillis(); |
| WeavingContext.getRefreshContext().setPersonalScopedBeanRefresh(sessionRefreshTime); |
| FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put(ScriptingConst.SESS_BEAN_REFRESH_TIMER, sessionRefreshTime); |
| } |
| |
| /** |
| * important, this method determines whether a managed bean class |
| * has to be refreshed or not |
| * |
| * @param tainted set of tainted classes |
| * @param managedBeanClass the class to be checked for refresh criteria |
| * @return true if the current bean class fulfills our refresh criteria |
| */ |
| protected boolean hasToBeRefreshed(Set<String> tainted, Class managedBeanClass) { |
| |
| return WeavingContext.isDynamic(managedBeanClass) && tainted.contains(managedBeanClass.getName()); |
| } |
| |
| /** |
| * returns the scripting engine which is attached |
| * to this bean handler |
| * |
| * @return the current scripting engine |
| */ |
| private int getScriptingEngine() { |
| return _scriptingEngine; |
| } |
| } |
