/***********************************************************************
* Copyright (c) 2008 by SAP AG, Walldorf.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* SAP AG - initial API and implementation
***********************************************************************/
package org.eclipse.jst.jee.model.internal.common;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.ElementChangedEvent;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IElementChangedListener;
import org.eclipse.jdt.core.IJavaElementDelta;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.model.IModelProviderEvent;
import org.eclipse.jst.j2ee.model.IModelProviderListener;
import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
import org.eclipse.jst.j2ee.project.WebUtilities;
import org.eclipse.jst.javaee.core.JavaEEObject;
import org.eclipse.jst.javaee.core.SecurityRole;
import org.eclipse.jst.javaee.core.SecurityRoleRef;
import org.eclipse.jst.javaee.ejb.SessionBean;
import org.eclipse.jst.jee.JEEPlugin;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.project.facet.core.IFacetedProject;
/**
* Base implementation for model providers based on annotations in java files.
*
* Listeners can be registered with {@link #addListener(IModelProviderListener)}
*
* @author Kiril Mitov k.mitov@sap.com
*
*/
public abstract class AbstractAnnotationModelProvider<T> implements IElementChangedListener, IModelProvider {
private static final String JAVA_EXTENSION = "java"; //$NON-NLS-1$
/**
* Find the security role with the given name in the given assembly
* descriptor.
*
* @param assembly
* @param name
* @return <code>null</code> if a security role with this name can not be
* found
*/
private static SecurityRole findRole(Collection<SecurityRole> securityRoles, String name) {
for (SecurityRole role : securityRoles) {
if (role.getRoleName().equals(name))
return role;
}
return null;
}
protected T modelObject;
private Collection<IModelProviderListener> listeners;
private Lock listenersLock = new ReentrantLock();
protected IFacetedProject facetedProject;
private ManyToOneRelation<SecurityRoleRef, SecurityRole> rolesToRolesRef = new ManyToOneRelation<SecurityRoleRef, SecurityRole>();
/**
* Constructs a new AnnotationReader for this faceted project. An illegal
* argument if a project with value <code>null</code> is passed. No loading
* is done in this constructor. Loading the model is made on demand when
* calling {@link #getModelObject()}.
*
* @param project
* the ejb project. Can not be <code>null</code>
*/
public AbstractAnnotationModelProvider(IFacetedProject project) {
if (project == null)
throw new IllegalArgumentException("The project argument can not be null"); //$NON-NLS-1$
this.facetedProject = project;
}
public T getConcreteModel() {
if (modelObject == null) {
preLoad();
try {
loadModel();
/*
* Adding the resource change listener after loading the model.
* No resource change event are acceptable while loading the
* model.
*/
postLoad();
} catch (CoreException e) {
log(e.getStatus());
return null;
}
}
return modelObject;
}
public Object getModelObject() {
return getConcreteModel();
}
public Object getModelObject(IPath modelPath) {
return getConcreteModel();
}
protected abstract void loadModel() throws CoreException;
protected void preLoad() {
}
protected void postLoad() {
JavaCore.addElementChangedListener(this);
}
/**
* Notifies the currently registered listeners with this model event. If the
* {@link IModelProviderEvent#getChangedResources()} is empty or
* <code>null</code> the method returns immediately.
*
* @param event
* the event that should be send to the listeners
*/
protected void notifyListeners(final IModelProviderEvent event) {
if (listeners == null)
return;
listenersLock.lock();
try {
IModelProviderListener[] backup = listeners.toArray(new IModelProviderListener[listeners.size()]);
notifyListeners(backup, event);
backup = null;
} finally {
listenersLock.unlock();
}
}
/**
* Clears the list of listeners. No notifications can occur while clearing
* the listeners.
*/
protected void clearListeners() {
if (listeners == null)
return;
try {
listenersLock.lock();
listeners.clear();
listeners = null;
} finally {
listenersLock.unlock();
}
}
private void notifyListeners(final IModelProviderListener[] aListeners, final IModelProviderEvent event) {
if (event.getChangedResources() == null || event.getChangedResources().isEmpty())
return;
for (final IModelProviderListener listener : aListeners) {
SafeRunner.run(new ISafeRunnable() {
public void handleException(Throwable exception) {
}
public void run() throws Exception {
listener.modelsChanged(event);
}
});
}
}
/**
* @return the currently registered listeners.
*/
protected Collection<IModelProviderListener> getListeners() {
if (listeners == null) {
listeners = new ArrayList<IModelProviderListener>();
}
return listeners;
}
/**
* Adds a listener to this instance. No listeners can be added during
* notifying the current listeners.
*
* @param listener
*/
public void addListener(IModelProviderListener listener) {
listenersLock.lock();
try {
getModelObject();
getListeners().add(listener);
} finally {
listenersLock.unlock();
}
}
/**
* Removes the listener from this instance. Has no effect if an identical
* listener is not registered.
*
* @param listener
* the listener to be removed.
*/
public void removeListener(IModelProviderListener listener) {
listenersLock.lock();
try {
getListeners().remove(listener);
} finally {
listenersLock.unlock();
}
}
/**
* @param javaProject
* @return true if the given project contains resources that are relative to
* the model. This method returns <code>true</code> for the
* ejbProject on which this instance is working a <code>true</code>
* for its client project.
*/
protected boolean isProjectRelative(IJavaProject javaProject) {
if (javaProject == null || facetedProject == null)
return false;
else if (javaProject.getProject().equals(facetedProject.getProject()))
return true;
else if(JavaEEProjectUtilities.isWebFragmentProject(javaProject.getProject()) &&
JavaEEProjectUtilities.isDynamicWebProject(facetedProject.getProject()) &&
isWebFragmentOf(facetedProject.getProject(), javaProject.getProject()))
return true;
return false;
}
private boolean isWebFragmentOf(IProject webProject, IProject webFragment) {
IVirtualComponent componentWebProject = ComponentCore.createComponent(webProject);
IVirtualComponent componentWebFragment = ComponentCore.createComponent(webFragment);
if(componentWebProject != null && componentWebFragment != null){
return WebUtilities.getWebFragments(componentWebProject).contains(componentWebFragment);
}
return false;
}
/**
* Dispose the current instance. The actual dispose may occur in another
* thread. Use {@link #addListener(IModelProviderListener)} to register a
* listener that will be notified when the instance is disposed. After all
* the listeners are notified the list of listeners is cleared.
*/
public void dispose() {
IModelProviderEvent modelEvent = createModelProviderEvent();
modelEvent.addResource(facetedProject.getProject());
modelEvent.setEventCode(IModelProviderEvent.UNLOADED_RESOURCE);
JavaCore.removeElementChangedListener(this);
modelObject = null;
notifyListeners(modelEvent);
clearListeners();
}
/**
* Process a unit as "removed". The method is allowed not to make checks
* whether the unit was added/removed/change. It is processing the unit as
* "removed".
*
* If no model object depends on the given file "modelEvent" is not changed.
*
* @see #processAddedCompilationUnit(IModelProviderEvent, ICompilationUnit)
* @param modelEvent
* subclasses should "fill" modelEvent with information about the
* change that has happened. This event will be propagated to
* model provided listeners.
* @param file
* the file to be removed.
* @throws CoreException
* if there was an error during parsing the file
*/
protected abstract void processRemovedCompilationUnit(IModelProviderEvent modelEvent, ICompilationUnit unit)
throws CoreException;
/**
* Process a unit as "added". The method is allowed not to make checks
* whether the unit was added/removed/change. It is processing the file as
* "added". It is the responsibility of the caller to make sure the
* processing of the file as added will not leave the model in a wrong
* state.
*
* modelEvent is changed to contain information about the added modelObject.
*
* @see #processRemovedCompilationUnit(IModelProviderEvent,
* ICompilationUnit)
* @param modelEvent
* subclasses should "fill" modelEvent with information about the
* change that has happened. This event will be propagated to
* model provided listeners.
* @param file
* the file that was added
* @throws CoreException
*/
protected abstract void processAddedCompilationUnit(IModelProviderEvent modelEvent, ICompilationUnit file)
throws CoreException;
/**
* Process a unit as "changed". The method is allowed not to make checks
* whether the unit was added/removed/change. It is processing the unit as
* "changed". It is the responsibility of the caller to make sure the
* processing of the file as "changed" will not leave the model in a wrong
* state.
*
* @see #processAddedCompilationUnit(IModelProviderEvent, ICompilationUnit)
* @see #processRemovedCompilationUnit(IModelProviderEvent,
* ICompilationUnit)
* @param modelEvent
* subclasses should "fill" modelEvent with information about the
* change that has happened. This event will be propagated to
* model provided listeners.
* @param unit
* the unti that was changed
* @throws CoreException
*/
protected abstract void processChangedCompilationUnit(IModelProviderEvent modelEvent, ICompilationUnit file)
throws CoreException;
protected void log(IStatus status) {
}
protected MyModelProviderEvent createModelProviderEvent() {
return new MyModelProviderEvent(0, null, facetedProject.getProject());
}
// ---------------SECURITY ROLES ---------------------------//
protected abstract Collection<SecurityRole> getSecurityRoles();
protected abstract Collection<SecurityRoleRef> getSecurityRoleRefs(JavaEEObject target);
/**
* Deletes the connection maintained by the given bean and the security
* roles defined in the bean. If this is the only bean in which the role is
* defined, the role will also be deleted. Calling this method makes sense
* only if the bean and the security role and the bean were connected with
* {@link #connectWithRole(SecurityRole, SessionBean)}
*
* <p>
* If the bean is not of type org.eclipse.jst.javaee.ejb.SessionBean the
* method returns immediately.
* </p>
*
* @see #connectWithRole(SecurityRole, SessionBean)
* @see #rolesToRolesRef
* @param bean
*/
protected void disconnectFromRoles(JavaEEObject target) {
Collection<SecurityRole> roles = getSecurityRoles();
if (roles == null)
return;
Collection<SecurityRoleRef> refs = getSecurityRoleRefs(target);
if (refs == null)
return;
for (SecurityRoleRef ref : refs) {
SecurityRole role = rolesToRolesRef.getTarget(ref);
rolesToRolesRef.disconnectSource(ref);
if (!rolesToRolesRef.containsTarget(role)) {
getSecurityRoles().remove(role);
}
}
}
/**
* A security role was found in the given file. Add this security role to
* the assembly descriptor. If the ejbJar does not have an assembly
* descriptor a new one is created.
*
* @see #connectRoleWithBean(SecurityRole, SessionBean)s
* @param file
* @param securityRole
*/
protected void securityRoleFound(JavaEEObject object, SecurityRole securityRole) {
connectWithRole(securityRole, object);
}
/**
* A security role can be defined in more the one bean. A bean can define
* more then one security role. This means we have a many-to-many relation
* between sessionBeans and securityRoles.
*
* <p>
* Luckily a sessionBean contains a list of securityRoleRefs. This method
* creates a connection between the securityRole contained in the assembly
* descriptor and the security role ref contained in the bean.
*
* If a security role is define only in one bean, deleting the bean means
* deleting the security role. But if the security role is defined in two
* beans only deleting both beans will result in deleting the security role.
* </p>
*
* @see #disconnectFromRoles(JavaEEObject)
* @see #rolesToRolesRef
* @param securityRole
* @param target
*/
private void connectWithRole(SecurityRole securityRole, JavaEEObject target) {
Collection<SecurityRole> roles = getSecurityRoles();
if (roles == null)
return;
Collection<SecurityRoleRef> refs = getSecurityRoleRefs(target);
if (refs == null)
return;
/*
* If there is a security role with this name use the existing security
* role.
*/
SecurityRole role = findRole(roles, securityRole.getRoleName());
if (role == null) {
roles.add(securityRole);
role = securityRole;
}
for (SecurityRoleRef ref : refs) {
if (ref.getRoleName().equals(role.getRoleName()))
rolesToRolesRef.connect(ref, role);
}
}
public void elementChanged(final ElementChangedEvent javaEvent) {
if (javaEvent.getType() == ElementChangedEvent.POST_RECONCILE)
internalPostReconcile(javaEvent);
else if (javaEvent.getType() == ElementChangedEvent.POST_CHANGE)
internalPostChange(javaEvent);
}
private void internalPostChange(ElementChangedEvent javaEvent) {
IModelProviderEvent modelEvent = createModelProviderEvent();
// handles ElementChangedEvent.POST_CHANGE - the case when the
// compilation unit has been changed
for (IJavaElementDelta child : javaEvent.getDelta().getAffectedChildren()) {
if (child.getElement() instanceof IJavaProject) {
processChangedProject(modelEvent, child);
notifyListeners(modelEvent);
}
}
}
private void internalPostReconcile(final ElementChangedEvent javaEvent) {
IModelProviderEvent modelEvent = createModelProviderEvent();
if (javaEvent.getDelta().getElement() instanceof ICompilationUnit) {
recursevilyProcessCompilationUnits(modelEvent, javaEvent.getDelta());
notifyListeners(modelEvent);
}
}
protected void processChangedProject(IModelProviderEvent event, IJavaElementDelta projectDelta) {
if (!isProjectRelative(projectDelta.getElement().getJavaProject())) {
return;
}
Assert.isTrue(projectDelta.getElement() instanceof IJavaProject,
"An invalid change notification has occured. Element is <" + projectDelta.getElement() + ">"); //$NON-NLS-1$//$NON-NLS-2$
if (((projectDelta.getFlags() & IJavaElementDelta.F_OPENED) != 0)
|| projectDelta.getKind() == IJavaElementDelta.ADDED) {
try {
loadModel();
} catch (CoreException e) {
JEEPlugin.getDefault().getLog().log(
new Status(IStatus.ERROR, JEEPlugin.getDefault().getPluginID(), e.getMessage(), e));
}
}
if (((projectDelta.getFlags() & IJavaElementDelta.F_CLOSED) != 0)
|| projectDelta.getKind() == IJavaElementDelta.REMOVED) {
dispose();
}
processChangedProjectChildren(event, projectDelta);
}
protected void processChangedProjectChildren(IModelProviderEvent event, IJavaElementDelta projectDelta) {
for (IJavaElementDelta childDelta : projectDelta.getAffectedChildren()) {
if (!(childDelta.getElement() instanceof IPackageFragmentRoot)) {
continue;
}
if ((childDelta.getFlags() & IJavaElementDelta.F_CHILDREN) != 0) {
recursevilyProcessPackages(event, childDelta);
}
}
}
public void recursevilyProcessPackages(IModelProviderEvent modelEvent, IJavaElementDelta delta) {
if (delta.getElement() instanceof IPackageFragment) {
try {
IPackageFragment fragment = (IPackageFragment) delta.getElement();
if (delta.getKind() == IJavaElementDelta.ADDED) {
for (ICompilationUnit unit : fragment.getCompilationUnits()) {
processAddedCompilationUnit(modelEvent, unit);
}
} else if (delta.getKind() == IJavaElementDelta.REMOVED) {
if (delta.getKind() == IJavaElementDelta.REMOVED) {
processRemovedPackage(modelEvent, delta);
}
} else if (delta.getKind() == IJavaElementDelta.CHANGED) {
recursevilyProcessCompilationUnits(modelEvent, delta);
}
} catch (CoreException e) {
JEEPlugin.getDefault().getLog().log(
new Status(IStatus.ERROR, JEEPlugin.getDefault().getPluginID(), e.getMessage(), e));
}
} else {
for (IJavaElementDelta childDelta : delta.getAffectedChildren()) {
recursevilyProcessPackages(modelEvent, childDelta);
}
}
}
protected abstract void processRemovedPackage(IModelProviderEvent modelEvent, IJavaElementDelta delta)
throws CoreException;
public void recursevilyProcessCompilationUnits(IModelProviderEvent modelEvent, IJavaElementDelta delta) {
if (delta.getElement() instanceof ICompilationUnit) {
if (!isProjectRelative(delta.getElement().getJavaProject()))
return;
try {
final ICompilationUnit unit = (ICompilationUnit) delta.getElement();
if (delta.getKind() == IJavaElementDelta.ADDED) {
processAddedCompilationUnit(modelEvent, unit);
}
if (delta.getKind() == IJavaElementDelta.REMOVED) {
processRemovedCompilationUnit(modelEvent, unit);
}
if (delta.getKind() == IJavaElementDelta.CHANGED) {
if (((delta.getFlags() & IJavaElementDelta.F_PRIMARY_RESOURCE) == 0)
|| ((delta.getFlags() & IJavaElementDelta.F_PRIMARY_WORKING_COPY) == 0)) {
modelEvent
.setEventCode(IModelProviderEvent.KNOWN_RESOURCES_CHANGED | modelEvent.getEventCode());
processChangedCompilationUnit(modelEvent, unit);
}
}
} catch (CoreException e) {
JEEPlugin.getDefault().getLog().log(
new Status(IStatus.ERROR, JEEPlugin.getDefault().getPluginID(), e.getMessage(), e));
}
} else {
for (IJavaElementDelta childDelta : delta.getAffectedChildren()) {
recursevilyProcessCompilationUnits(modelEvent, childDelta);
}
}
}
protected void visitJavaFiles(final Collection<ICompilationUnit> javaFiles, final IPackageFragmentRoot root)
throws CoreException {
if (root.getKind() != IPackageFragmentRoot.K_SOURCE)
return;
root.getCorrespondingResource().accept(new IResourceProxyVisitor() {
public boolean visit(IResourceProxy proxy) throws CoreException {
if (proxy.getType() == IResource.FILE) {
if (proxy.getName().endsWith("." + JAVA_EXTENSION)) { //$NON-NLS-1$
IFile file = (IFile) proxy.requestResource();
if (!root.getJavaProject().isOnClasspath(file))
return false;
if (!file.isSynchronized(IResource.DEPTH_ONE))
return false;
javaFiles.add(JavaCore.createCompilationUnitFrom(file));
}
return false;
}
return true;
}
}, IContainer.NONE);
}
}