| /****************************************************************************** |
| * Copyright (c) 2005, 2007 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 |
| ******************************************************************************/ |
| |
| package org.eclipse.jst.j2ee.internal.archive; |
| |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findExtensions; |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findOptionalElement; |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findRequiredAttribute; |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findRequiredElement; |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.getTopLevelElements; |
| import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.instantiate; |
| import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.PLUGIN_ID; |
| import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.createErrorStatus; |
| import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.log; |
| import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.eclipse.core.expressions.EvaluationContext; |
| import org.eclipse.core.expressions.EvaluationResult; |
| import org.eclipse.core.expressions.Expression; |
| import org.eclipse.core.expressions.ExpressionConverter; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtension; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IExtensionRegistry; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.jst.j2ee.archive.IArchiveExportParticipant; |
| import org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.InvalidExtensionException; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.wst.common.project.facet.core.runtime.IRuntime; |
| import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponent; |
| import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponentType; |
| import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponentVersion; |
| import org.eclipse.wst.common.project.facet.core.runtime.RuntimeManager; |
| import org.osgi.framework.Bundle; |
| |
| /** |
| * Contains the logic for processing the <code>org.eclipse.jst.j2ee.archiveExportParticipants</code> |
| * extension point. |
| * |
| * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a> |
| */ |
| |
| public final class ArchiveExportParticipantsExtensionPoint |
| { |
| public static final String EXTENSION_POINT_ID = "archiveExportParticipants"; //$NON-NLS-1$ |
| |
| private static final String EL_PARTICIPANT = "participant"; //$NON-NLS-1$ |
| private static final String EL_RUNTIME_COMPONENT = "runtime-component"; //$NON-NLS-1$ |
| private static final String EL_FACTORY = "factory"; //$NON-NLS-1$ |
| private static final String EL_ENABLEMENT = "enablement"; //$NON-NLS-1$ |
| private static final String ATTR_ID = "id"; //$NON-NLS-1$ |
| private static final String ATTR_TYPE = "type"; //$NON-NLS-1$ |
| private static final String ATTR_VERSION = "version"; //$NON-NLS-1$ |
| private static final String ATTR_CLASS = "class"; //$NON-NLS-1$ |
| |
| private static List<ParticipantInfo> extensions = null; |
| |
| public static class ParticipantInfo |
| { |
| private String id; |
| private String pluginId = null; |
| private String className = null; |
| private IRuntimeComponentType runtimeComponentType = null; |
| private String runtimeComponentVersionExpr = null; |
| private Expression enablementCondition = null; |
| |
| public String getId() |
| { |
| return this.id; |
| } |
| |
| public IArchiveExportParticipant loadParticipant() |
| { |
| try |
| { |
| return instantiate( this.pluginId, this.className, IArchiveExportParticipant.class ); |
| } |
| catch( CoreException e ) |
| { |
| log( e.getStatus() ); |
| return null; |
| } |
| } |
| } |
| |
| public static List<ParticipantInfo> getExtensions( final IProject project, |
| final IRuntime runtime ) |
| { |
| readExtensions(); |
| |
| final List<ParticipantInfo> result = new ArrayList<ParticipantInfo>(); |
| |
| for( ParticipantInfo partInfo : extensions ) |
| { |
| boolean match = false; |
| |
| for( IRuntimeComponent rc : runtime.getRuntimeComponents() ) |
| { |
| final IRuntimeComponentType rct = rc.getRuntimeComponentType(); |
| |
| if( rct == partInfo.runtimeComponentType ) |
| { |
| final IRuntimeComponentVersion rcv = rc.getRuntimeComponentVersion(); |
| |
| try |
| { |
| if( rct.getVersions( partInfo.runtimeComponentVersionExpr ).contains( rcv ) ) |
| { |
| match = true; |
| break; |
| } |
| } |
| catch( CoreException e ) |
| { |
| logError( -1, e.getMessage(), e ); |
| } |
| } |
| } |
| |
| if( match && partInfo.enablementCondition != null ) |
| { |
| final EvaluationContext evalContext = new EvaluationContext( null, project ); |
| evalContext.setAllowPluginActivation( true ); |
| |
| try |
| { |
| final EvaluationResult evalResult |
| = partInfo.enablementCondition.evaluate( evalContext ); |
| |
| if( evalResult != EvaluationResult.TRUE ) |
| { |
| match = false; |
| } |
| } |
| catch( CoreException e ) |
| { |
| logError( -1, e.getMessage(), e ); |
| } |
| } |
| |
| if( match ) |
| { |
| result.add( partInfo ); |
| } |
| } |
| |
| return Collections.unmodifiableList( result ); |
| } |
| |
| private static synchronized void readExtensions() |
| { |
| if( extensions != null ) |
| { |
| return; |
| } |
| |
| extensions = new ArrayList<ParticipantInfo>(); |
| |
| for( IConfigurationElement element |
| : getTopLevelElements( findExtensions( PLUGIN_ID, EXTENSION_POINT_ID ) ) ) |
| { |
| if( element.getName().equals( EL_PARTICIPANT ) ) |
| { |
| try |
| { |
| readExtension( element ); |
| } |
| catch( InvalidExtensionException e ) |
| { |
| // Continue. The problem has been reported to the user via the log. |
| } |
| } |
| } |
| } |
| |
| private static void readExtension( final IConfigurationElement config ) |
| |
| throws InvalidExtensionException |
| |
| { |
| final ParticipantInfo info = new ParticipantInfo(); |
| |
| info.pluginId = config.getContributor().getName(); |
| info.id = info.pluginId + "." + findRequiredAttribute( config, ATTR_ID ); //$NON-NLS-1$ |
| |
| final IConfigurationElement elFactory = findRequiredElement( config, EL_FACTORY ); |
| info.className = findRequiredAttribute( elFactory, ATTR_CLASS ); |
| |
| final IConfigurationElement elRuntimeComponent |
| = findRequiredElement( config, EL_RUNTIME_COMPONENT ); |
| |
| final String rcTypeString = findRequiredAttribute( elRuntimeComponent, ATTR_TYPE ); |
| |
| if( ! RuntimeManager.isRuntimeComponentTypeDefined( rcTypeString ) ) |
| { |
| // TODO: Log the problem |
| throw new InvalidExtensionException(); |
| } |
| |
| info.runtimeComponentType = RuntimeManager.getRuntimeComponentType( rcTypeString ); |
| info.runtimeComponentVersionExpr = elRuntimeComponent.getAttribute( ATTR_VERSION ); |
| |
| final IConfigurationElement elEnablement = findOptionalElement( config, EL_ENABLEMENT ); |
| |
| try |
| { |
| info.enablementCondition = ExpressionConverter.getDefault().perform( elEnablement ); |
| } |
| catch( CoreException e ) |
| { |
| logError( -1, e.getMessage(), e ); |
| throw new InvalidExtensionException(); |
| } |
| |
| extensions.add( info ); |
| } |
| |
| /** |
| * Utility methods that are helpful for implementing extension points. |
| * |
| * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a> |
| */ |
| |
| public static final class PluginUtil |
| { |
| public static final class InvalidExtensionException |
| |
| extends Exception |
| |
| { |
| private static final long serialVersionUID = 1L; |
| } |
| |
| private PluginUtil() {} |
| |
| public static Collection<IExtension> findExtensions( final String pluginId, |
| final String extensionPointId ) |
| { |
| final IExtensionRegistry registry = Platform.getExtensionRegistry(); |
| final IExtensionPoint point = registry.getExtensionPoint( pluginId, extensionPointId ); |
| |
| if( point == null ) |
| { |
| throw new RuntimeException(); |
| } |
| |
| final List<IExtension> extensions = new ArrayList<IExtension>(); |
| |
| for( IExtension extension : point.getExtensions() ) |
| { |
| extensions.add( extension ); |
| } |
| |
| return extensions; |
| } |
| |
| public static Collection<IConfigurationElement> getTopLevelElements( final Collection<IExtension> extensions ) |
| { |
| final List<IConfigurationElement> elements = new ArrayList<IConfigurationElement>(); |
| |
| for( IExtension extension : extensions ) |
| { |
| for( IConfigurationElement element : extension.getConfigurationElements() ) |
| { |
| elements.add( element ); |
| } |
| } |
| |
| return elements; |
| } |
| |
| public static void reportMissingAttribute( final IConfigurationElement el, |
| final String attribute ) |
| { |
| final String pluginId = el.getContributor().getName(); |
| final String extPointId = el.getDeclaringExtension().getExtensionPointUniqueIdentifier(); |
| |
| final String msg |
| = Resources.bind( Resources.missingAttribute, pluginId, extPointId, el.getName(), |
| attribute ); |
| |
| log( createErrorStatus( -1, msg, null ) ); |
| } |
| |
| public static void reportMissingElement( final IConfigurationElement el, |
| final String element ) |
| { |
| final String pluginId = el.getContributor().getName(); |
| final String extPointId = el.getDeclaringExtension().getExtensionPointUniqueIdentifier(); |
| |
| final String msg |
| = Resources.bind( Resources.missingElement, pluginId, extPointId, el.getName(), |
| element ); |
| |
| log( createErrorStatus( -1, msg, null ) ); |
| } |
| |
| public static String findRequiredAttribute( final IConfigurationElement el, |
| final String attribute ) |
| |
| throws InvalidExtensionException |
| |
| { |
| final String val = el.getAttribute( attribute ); |
| |
| if( val == null ) |
| { |
| reportMissingAttribute( el, attribute ); |
| throw new InvalidExtensionException(); |
| } |
| |
| return val; |
| } |
| |
| public static IConfigurationElement findRequiredElement( final IConfigurationElement el, |
| final String childElement ) |
| |
| throws InvalidExtensionException |
| |
| { |
| final IConfigurationElement[] children = el.getChildren( childElement ); |
| |
| if( children.length == 0 ) |
| { |
| reportMissingElement( el, childElement ); |
| throw new InvalidExtensionException(); |
| } |
| |
| return children[ 0 ]; |
| } |
| |
| public static IConfigurationElement findOptionalElement( final IConfigurationElement el, |
| final String childElement ) |
| { |
| final IConfigurationElement[] children = el.getChildren( childElement ); |
| |
| if( children.length == 0 ) |
| { |
| return null; |
| } |
| return children[ 0 ]; |
| } |
| |
| public static String getElementValue( final IConfigurationElement el, |
| final String defaultValue ) |
| { |
| if( el != null ) |
| { |
| String text = el.getValue(); |
| |
| if( text != null ) |
| { |
| text = text.trim(); |
| |
| if( text.length() > 0 ) |
| { |
| return text; |
| } |
| } |
| } |
| |
| return defaultValue; |
| } |
| |
| @SuppressWarnings( "unchecked" ) |
| public static <T> T instantiate( final String pluginId, |
| final String clname, |
| final Class<T> interfc ) |
| |
| throws CoreException |
| |
| { |
| final Bundle bundle = Platform.getBundle( pluginId ); |
| |
| final Object obj; |
| |
| try |
| { |
| final Class cl = bundle.loadClass( clname ); |
| obj = cl.newInstance(); |
| } |
| catch( Exception e ) |
| { |
| final String msg = NLS.bind( Resources.failedToCreate, clname ); |
| throw new CoreException( createErrorStatus( -1, msg, e ) ); |
| } |
| |
| if( ! interfc.isAssignableFrom( obj.getClass() ) ) |
| { |
| final String msg |
| = NLS.bind( Resources.doesNotImplement, clname, interfc.getClass().getName() ); |
| |
| throw new CoreException( createErrorStatus( -1, msg, null ) ); |
| } |
| |
| return (T) obj; |
| } |
| |
| private static final class Resources |
| |
| extends NLS |
| |
| { |
| public static String missingAttribute; |
| public static String missingElement; |
| public static String failedToCreate; |
| public static String doesNotImplement; |
| |
| static |
| { |
| initializeMessages( PluginUtil.class.getName(), Resources.class ); |
| } |
| |
| public static String bind( final String message, |
| final String arg1, |
| final String arg2, |
| final String arg3, |
| final String arg4 ) |
| { |
| return bind( message, new Object[] { arg1, arg2, arg3, arg4 } ); |
| } |
| } |
| |
| } |
| |
| } |
