| /******************************************************************************* |
| * Copyright (c) 2010, 2011 EclipseSource and others. 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: |
| * Holger Staudacher - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.libra.warproducts.ui.validation; |
| |
| import java.util.*; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.libra.warproducts.core.IWARProduct; |
| import org.eclipse.libra.warproducts.core.validation.*; |
| import org.eclipse.libra.warproducts.ui.Messages; |
| import org.eclipse.osgi.service.resolver.ResolverError; |
| import org.eclipse.osgi.service.resolver.VersionConstraint; |
| import org.eclipse.pde.core.plugin.IPluginModelBase; |
| import org.eclipse.pde.core.plugin.PluginRegistry; |
| import org.eclipse.pde.internal.core.TargetPlatformHelper; |
| import org.eclipse.pde.internal.core.iproduct.IProductPlugin; |
| import org.eclipse.pde.internal.launching.launcher.LaunchValidationOperation; |
| import org.eclipse.pde.internal.launching.launcher.ProductValidationOperation; |
| import org.eclipse.pde.internal.ui.PDEPlugin; |
| import org.eclipse.pde.internal.ui.PDEPluginImages; |
| |
| public class WARProductValidateAction extends Action { |
| |
| IWARProduct product; |
| List<IValidationListener> listeners; |
| |
| public WARProductValidateAction( final IWARProduct product ) { |
| super( Messages.ValidateActionTitle, IAction.AS_PUSH_BUTTON ); |
| setImageDescriptor( PDEPluginImages.DESC_VALIDATE_TOOL ); |
| this.product = product; |
| } |
| |
| public void addValidationListener( final IValidationListener listener ) { |
| if( listeners == null ) { |
| listeners = new ArrayList<IValidationListener>(); |
| } |
| if( !listeners.contains( listener ) ) { |
| listeners.add( listener ); |
| } |
| } |
| |
| public void run() { |
| HashMap<String,IPluginModelBase> map = new HashMap<String,IPluginModelBase>(); |
| IProductPlugin[] plugins = product.getPlugins(); |
| for( int i = 0; i < plugins.length; i++ ) { |
| String id = plugins[ i ].getId(); |
| addBundleIfExisting( map, id ); |
| } |
| validate( map ); |
| } |
| |
| private static void addBundleIfExisting( final Map<String,IPluginModelBase> map, final String id ) { |
| if( id != null && !map.containsKey( id ) ) { |
| IPluginModelBase model = PluginRegistry.findModel( id ); |
| if( bundleExist( id, model ) ) { |
| map.put( id, model ); |
| } |
| } |
| } |
| |
| private static boolean bundleExist( final String id, final IPluginModelBase model ) { |
| boolean result = false; |
| if( model != null ) { |
| boolean matchesCurrentEnvironment |
| = TargetPlatformHelper.matchesCurrentEnvironment( model ); |
| if( matchesCurrentEnvironment ) { |
| result = true; |
| } |
| } |
| return result; |
| } |
| |
| private void validate( final Map<String,IPluginModelBase> map ) { |
| try { |
| IPluginModelBase[] baseModel = new IPluginModelBase[ map.size() ]; |
| IPluginModelBase[] models = map.values().toArray( baseModel ); |
| LaunchValidationOperation operation |
| = new ProductValidationOperation( models ); |
| operation.run( new NullProgressMonitor() ); |
| verifyResult( operation ); |
| } catch( final CoreException e ) { |
| PDEPlugin.logException( e ); |
| } |
| } |
| |
| private void verifyResult( final LaunchValidationOperation operation ) |
| { |
| Map<Object,Object[]> errors = operation.getInput(); |
| verifyPDEErrors( errors ); |
| validateWarContent( errors ); |
| notifyListeners( errors ); |
| } |
| |
| private void notifyListeners( final Map errors ) { |
| if( listeners != null ) { |
| for( int i = 0; i < listeners.size(); i++ ) { |
| IValidationListener listener = listeners.get( i ); |
| listener.validationFinished( errors ); |
| } |
| } |
| } |
| |
| private static void verifyPDEErrors( final Map<Object,Object[]> map ) { |
| final ArrayList<Object> keys = new ArrayList<Object>(map.size()); |
| keys.addAll( map.keySet() ); |
| |
| for(final Object currentKey: keys){ |
| ResolverError[] errors = (ResolverError[]) map.get( currentKey ); |
| ResolverError[] validErrors = validateErrors( errors ); |
| map.remove( currentKey ); |
| if( validErrors.length > 0 ) { |
| map.put( currentKey, validErrors ); |
| } |
| } |
| } |
| |
| private static ResolverError[] validateErrors( final ResolverError[] errors ) { |
| List<ResolverError> validErrors = new ArrayList<ResolverError>(); |
| for( int i = 0; i < errors.length; i++ ) { |
| ResolverError error = errors[ i ]; |
| VersionConstraint constraint = error.getUnsatisfiedConstraint(); |
| if( constraint != null ) { |
| String unresolvedBundleId = constraint.getName(); |
| if (unresolvedBundleId==null){ |
| continue; |
| } |
| |
| if( !isBanned( unresolvedBundleId ) |
| && !unresolvedBundleId.equals( Validator.SERVLET_BRIDGE_ID ) ) |
| { |
| validErrors.add( error ); |
| } |
| } |
| } |
| ResolverError[] result = new ResolverError[ validErrors.size() ]; |
| validErrors.toArray( result ); |
| return result; |
| } |
| |
| private static boolean isBanned( final String unresolvedBundleId ) { |
| boolean result = false; |
| String[] bannedBundles = Validator.BANNED_BUNDLES; |
| for( int i = 0; i < bannedBundles.length && !result; i++ ) { |
| if( unresolvedBundleId.indexOf( bannedBundles[ i ] ) != -1 ) { |
| result = true; |
| } |
| } |
| return result; |
| } |
| |
| private void validateWarContent( final Map<Object,Object[]> map ) { |
| Validator validator = new Validator( product ); |
| Validation validation = validator.validate(); |
| if( !validation.isValid() ) { |
| handleWARValidationErrors( map, validation.getErrors() ); |
| } |
| } |
| |
| private static void handleWARValidationErrors( final Map<Object,Object[]> map, |
| final ValidationError[] errors ) |
| { |
| String key = Messages.ValidateAction; |
| map.put( key, errors ); |
| } |
| |
| } |