/******************************************************************************
* Copyright (c) 2005 BEA Systems, Inc.
* 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:
* Konstantin Komissarchik - initial API and implementation
******************************************************************************/
package org.eclipse.jst.j2ee.project.facet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
import org.eclipse.jst.common.project.facet.core.IClasspathProvider;
import org.eclipse.jst.common.project.facet.core.internal.FacetCorePlugin;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.project.facet.core.IDelegate;
import org.eclipse.wst.common.project.facet.core.IFacetedProject;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.IRuntimeChangedEvent;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
import org.osgi.service.prefs.BackingStoreException;
/**
* @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
*/
public final class J2EEFacetRuntimeChangedDelegate
implements IDelegate
{
public static final String LEGACY_METADATA_FILE_NAME
= ".settings/org.eclipse.jst.common.project.facet.core.prefs"; //$NON-NLS-1$
private static final String OWNER_PROJECT_FACETS_ATTR = "owner.project.facets"; //$NON-NLS-1$
public void execute( final IProject project,
final IProjectFacetVersion fv,
final Object cfg,
final IProgressMonitor monitor )
throws CoreException
{
if( monitor != null )
{
monitor.beginTask( "", 11 ); //$NON-NLS-1$
}
try
{
IRuntimeChangedEvent event = (IRuntimeChangedEvent)cfg;
// Using our remove Utility to first check for missing preferences
removeClasspathEntries( project, fv, event.getOldRuntime());
if( ! ClasspathHelper.addClasspathEntries( project, fv ) )
{
// TODO: Support the no runtime case.
// ClasspathHelper.addClasspathEntries( project, fv, <something> );
}
if( monitor != null )
{
monitor.worked( 1 );
}
// Cascade this runtime change to projects referenced by this project
// Compile the list of projects referenced by this project.
final Set<IProject> childProjects = new HashSet<IProject>();
final IVirtualComponent projectVC = ComponentCore.createComponent( project );
Map<String, Object> options = new HashMap<String, Object>();
options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.HARD_REFERENCES);
final IVirtualReference[] vrefs = projectVC.getReferences(options);
for( int i = 0; i < vrefs.length; i++ ) {
final IVirtualReference vref = vrefs[ i ];
final IVirtualComponent vc = vref.getReferencedComponent();
childProjects.add( vc.getProject() );
}
if( monitor != null ) {
monitor.worked( 1 );
}
// Attempt to change the runtime for each of the referenced projects.
updateProjectRuntime( project, childProjects, submon( monitor, 9 ) );
}
finally
{
if( monitor != null )
{
monitor.done();
}
}
}
private void removeClasspathEntries(IProject project, IProjectFacetVersion fv, IRuntime oldRuntime) throws CoreException {
IJavaProject jproj = JavaCore.create(project);
List cp = getClasspath(jproj);
boolean hasPrefs = hasClasspathPreferencesNode(project);
// In the case where no prefs exists... make sure the entries of the
// oldRuntime are removed before continuing
if (!hasPrefs) {
removeOnlyCPEntries(project, fv, jproj, cp, oldRuntime);
} else
ClasspathHelper.removeClasspathEntries(project, fv);
}
private boolean hasClasspathPreferencesNode(IProject project) {
IProject pj = project.getProject();
IFile legacyMetadataFile = pj.getFile( LEGACY_METADATA_FILE_NAME );
// First check if file exists
if( legacyMetadataFile.exists() ) {
ProjectScope scope = new ProjectScope(project);
IEclipsePreferences pluginRoot = scope.getNode(FacetCorePlugin.PLUGIN_ID);
try {
return pluginRoot.nodeExists("classpath.helper"); //$NON-NLS-1$
} catch (BackingStoreException e) {
org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
}
}
//Now check classpath entries for new attributes
IJavaProject jproj = JavaCore.create( project );
return hasClasspathPreferencesNode(jproj);
}
private boolean hasClasspathPreferencesNode(IJavaProject jproj) {
boolean attributeFound = false;
IClasspathEntry[] entries = null;
try {
entries = jproj.getRawClasspath();
} catch (JavaModelException e) {
org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
}
int i = 0;
if (entries != null) {
while (!attributeFound && i < entries.length) {
IClasspathEntry cpe = entries[i];
attributeFound = hasOwnerAttribute( cpe );
i++;
}
}
return attributeFound;
}
private boolean hasOwnerAttribute(IClasspathEntry cpe) {
if( cpe != null )
{
for( IClasspathAttribute attr : cpe.getExtraAttributes() )
{
if( attr.getName().equals( OWNER_PROJECT_FACETS_ATTR ) )
return true;
}
}
return false;
}
private void removeOnlyCPEntries(final IProject project, final IProjectFacetVersion fv, final IJavaProject jproj, final List cp,
IRuntime oldRuntime) throws CoreException {
IFacetedProject fproj = ProjectFacetsManager.create(project);
IRuntime runtime = (oldRuntime != null) ? oldRuntime : fproj.getPrimaryRuntime();
if (runtime != null) {
IClasspathProvider cpprov = (IClasspathProvider) runtime.getAdapter(IClasspathProvider.class);
List cpentries = cpprov.getClasspathEntries(fv);
boolean realCPChanged = false;
if (cpentries != null) {
for (Iterator itr = cpentries.iterator(); itr.hasNext();) {
IClasspathEntry cpentry = (IClasspathEntry) itr.next();
IPath path = cpentry.getPath();
boolean contains = cp.contains(cpentry);
if (contains) {
for (Iterator itr2 = cp.iterator(); itr2.hasNext();) {
final IClasspathEntry realEntry = (IClasspathEntry) itr2.next();
if (realEntry.getPath().equals(path)) {
itr2.remove();
realCPChanged = true;
break;
}
}
}
}
}
if (realCPChanged) {
IClasspathEntry[] newcp = (IClasspathEntry[]) cp.toArray(new IClasspathEntry[cp.size()]);
jproj.setRawClasspath(newcp, null);
}
}
}
private List getClasspath(final IJavaProject jproj)
throws CoreException
{
ArrayList list = new ArrayList();
IClasspathEntry[] cp = jproj.getRawClasspath();
for (int i = 0; i < cp.length; i++) {
list.add(cp[i]);
}
return list;
}
private static IProgressMonitor submon( final IProgressMonitor parent, final int ticks ) {
return ( parent == null ? null : new SubProgressMonitor( parent, ticks ) );
}
public static void updateProjectRuntime( final IProject project,
final IProject childProject,
final IProgressMonitor monitor ) throws CoreException {
if( monitor != null ) {
monitor.beginTask( "", 1 ); //$NON-NLS-1$
}
try
{
final IFacetedProject facetedProject = ProjectFacetsManager.create( project );
final IRuntime projectRuntime = facetedProject.getRuntime();
final IFacetedProject childFacetedProject = ProjectFacetsManager.create( childProject );
if( childFacetedProject != null &&
! equals(projectRuntime, childFacetedProject.getRuntime()))
{
boolean supports = true;
if( projectRuntime != null )
{
for( Iterator itr = childFacetedProject.getProjectFacets().iterator(); itr.hasNext(); ) {
final IProjectFacetVersion fver = (IProjectFacetVersion) itr.next();
if(!projectRuntime.supports(fver)) {
supports = false;
break;
}
}
}
if( supports ) {
childFacetedProject.setRuntime(projectRuntime, submon( monitor, 1 ) );
}
}
}
finally {
if( monitor != null ) {
monitor.done();
}
}
}
public static void updateProjectRuntime( final IProject project,
final Set<IProject> childProjects,
final IProgressMonitor monitor ) throws CoreException {
if( monitor != null ) {
monitor.beginTask( "", childProjects.size() ); //$NON-NLS-1$
}
try {
for(final IProject childProject : childProjects) {
updateProjectRuntime( project, childProject,
submon( monitor, 1 ) );
}
}
finally {
if( monitor != null ) {
monitor.done();
}
}
}
private static boolean equals( final Object obj1, final Object obj2 ) {
if( obj1 == obj2 ) {
return true;
} else if( obj1 == null || obj2 == null ) {
return false;
} else {
return obj1.equals( obj2 );
}
}
}