/*
* 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.tuscany.maven.plugin.eclipse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
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 java.util.TreeSet;
import java.util.jar.Manifest;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactCollector;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.resolver.DebugResolutionListener;
import org.apache.maven.artifact.resolver.ResolutionNode;
import org.apache.maven.artifact.resolver.WarningResolutionListener;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.execution.RuntimeInformation;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.apache.maven.model.Exclusion;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.eclipse.Constants;
import org.apache.maven.plugin.eclipse.Messages;
import org.apache.maven.plugin.ide.IdeDependency;
import org.apache.maven.plugin.ide.IdeUtils;
import org.apache.maven.project.MavenProject;
import org.apache.tuscany.maven.bundle.plugin.BundleUtil;
import org.codehaus.plexus.logging.LogEnabled;
import org.codehaus.plexus.logging.Logger;
/**
* Abstract base plugin which takes care of the common stuff usually needed by maven IDE plugins. A plugin extending
* AbstractIdeSupportMojo should implement the setup()
and writeConfiguration()
methods, plus
* the getters needed to get the various configuration flags and required components. The lifecycle:
*
*
* *** calls setup() where you can configure your specific stuff and stop the mojo from execute if appropriate *** * - manually resolve project dependencies, NOT failing if a dependency is missing * - compute project references (reactor projects) if the getUseProjectReferences() flag is set * - download sources/javadocs if the getDownloadSources() flag is set * *** calls writeConfiguration(), passing the list of resolved referenced dependencies *** * - report the list of missing sources or just tell how to turn this feature on if the flag was disabled ** * @author Fabrizio Giustina * @version $Id: AbstractIdeSupportMojo.java 727620 2008-12-18 02:35:18Z baerrach $ */ public abstract class AbstractIdeSupportMojo extends AbstractMojo implements LogEnabled { /** * Is it an PDE project? If yes, the plugin adds the necessary natures and build commands to the .project file. * Additionally it copies all libraries to a project local directory and references them instead of referencing the * files in the local Maven repository. It also ensured that the "Bundle-Classpath" in META-INF/MANIFEST.MF is * synchronized. * * @parameter expression="${eclipse.pde}" default-value="true" */ protected boolean pde; /** * The project whose project files to create. * * @parameter expression="${project}" * @required * @readonly */ protected MavenProject project; /** * The currently executed project (can be a reactor project). * * @parameter expression="${executedProject}" * @readonly */ protected MavenProject executedProject; /** * The project packaging. * * @parameter expression="${project.packaging}" */ protected String packaging; /** * Artifact factory, needed to download source jars for inclusion in classpath. * * @component role="org.apache.maven.artifact.factory.ArtifactFactory" * @required * @readonly */ protected ArtifactFactory artifactFactory; /** * Artifact resolver, needed to download source jars for inclusion in classpath. * * @component role="org.apache.maven.artifact.resolver.ArtifactResolver" * @required * @readonly */ protected ArtifactResolver artifactResolver; /** * Artifact collector, needed to resolve dependencies. * * @component role="org.apache.maven.artifact.resolver.ArtifactCollector" * @required * @readonly */ protected ArtifactCollector artifactCollector; /** * @component role="org.apache.maven.artifact.metadata.ArtifactMetadataSource" hint="maven" */ protected ArtifactMetadataSource artifactMetadataSource; /** * The runtime information for Maven, used to retrieve Maven's version number. * * @component */ private RuntimeInformation runtimeInformation; /** * Remote repositories which will be searched for source attachments. * * @parameter expression="${project.remoteArtifactRepositories}" * @required * @readonly */ protected List remoteArtifactRepositories; /** * Local maven repository. * * @parameter expression="${localRepository}" * @required * @readonly */ protected ArtifactRepository localRepository; /** * If the executed project is a reactor project, this will contains the full list of projects in the reactor. * * @parameter expression="${reactorProjects}" * @required * @readonly */ protected List reactorProjects; /** * Skip the operation when true. * * @parameter expression="${eclipse.skip}" default-value="false" */ private boolean skip; /** * Enables/disables the downloading of source attachments. Defaults to false. When this flag is
true
* remote repositories are checked for sources: in order to avoid repeated check for unavailable source archives, a
* status cache is mantained. To reset this cache run mvn eclipse:remove-cache
, or use the
* forceRecheck
option.
*
* @parameter expression="${downloadSources}"
*/
protected boolean downloadSources;
/**
* Enables/disables the downloading of javadoc attachments. Defaults to false. When this flag is true
* remote repositories are checked for javadocs: in order to avoid repeated check for unavailable javadoc archives,
* a status cache is mantained. To reset this cache run mvn eclipse:remove-cache
, or use the
* forceRecheck
option.
*
* @parameter expression="${downloadJavadocs}"
*/
protected boolean downloadJavadocs;
/**
* Enables/disables the rechecking of the remote repository for downloading source/javadoc attachments. Defaults to
* false. When this flag is true
and the source or javadoc attachment has a status cache to indicate
* that it is not available, then the remote repository will be rechecked for a source or javadoc attachment and the
* status cache updated to reflect the new state.
*
* @parameter expression="${forceRecheck}"
*/
protected boolean forceRecheck;
/**
* Plexus logger needed for debugging manual artifact resolution.
*/
protected Logger logger;
/**
* Getter for artifactMetadataSource
.
*
* @return Returns the artifactMetadataSource.
*/
public ArtifactMetadataSource getArtifactMetadataSource()
{
return artifactMetadataSource;
}
/**
* Setter for artifactMetadataSource
.
*
* @param artifactMetadataSource The artifactMetadataSource to set.
*/
public void setArtifactMetadataSource( ArtifactMetadataSource artifactMetadataSource )
{
this.artifactMetadataSource = artifactMetadataSource;
}
/**
* Getter for project
.
*
* @return Returns the project.
*/
public MavenProject getProject()
{
return project;
}
/**
* Setter for project
.
*
* @param project The project to set.
*/
public void setProject( MavenProject project )
{
this.project = project;
}
/**
* Getter for reactorProjects
.
*
* @return Returns the reactorProjects.
*/
public List getReactorProjects()
{
return reactorProjects;
}
/**
* Setter for reactorProjects
.
*
* @param reactorProjects The reactorProjects to set.
*/
public void setReactorProjects( List reactorProjects )
{
this.reactorProjects = reactorProjects;
}
/**
* Getter for remoteArtifactRepositories
.
*
* @return Returns the remoteArtifactRepositories.
*/
public List getRemoteArtifactRepositories()
{
return remoteArtifactRepositories;
}
/**
* Setter for remoteArtifactRepositories
.
*
* @param remoteArtifactRepositories The remoteArtifactRepositories to set.
*/
public void setRemoteArtifactRepositories( List remoteArtifactRepositories )
{
this.remoteArtifactRepositories = remoteArtifactRepositories;
}
/**
* Getter for artifactFactory
.
*
* @return Returns the artifactFactory.
*/
public ArtifactFactory getArtifactFactory()
{
return artifactFactory;
}
/**
* Setter for artifactFactory
.
*
* @param artifactFactory The artifactFactory to set.
*/
public void setArtifactFactory( ArtifactFactory artifactFactory )
{
this.artifactFactory = artifactFactory;
}
/**
* Getter for artifactResolver
.
*
* @return Returns the artifactResolver.
*/
public ArtifactResolver getArtifactResolver()
{
return artifactResolver;
}
/**
* Setter for artifactResolver
.
*
* @param artifactResolver The artifactResolver to set.
*/
public void setArtifactResolver( ArtifactResolver artifactResolver )
{
this.artifactResolver = artifactResolver;
}
/**
* Getter for executedProject
.
*
* @return Returns the executedProject.
*/
public MavenProject getExecutedProject()
{
return executedProject;
}
/**
* Setter for executedProject
.
*
* @param executedProject The executedProject to set.
*/
public void setExecutedProject( MavenProject executedProject )
{
this.executedProject = executedProject;
}
/**
* Getter for localRepository
.
*
* @return Returns the localRepository.
*/
public ArtifactRepository getLocalRepository()
{
return localRepository;
}
/**
* Setter for localRepository
.
*
* @param localRepository The localRepository to set.
*/
public void setLocalRepository( ArtifactRepository localRepository )
{
this.localRepository = localRepository;
}
/**
* Getter for downloadJavadocs
.
*
* @return Returns the downloadJavadocs.
*/
public boolean getDownloadJavadocs()
{
return downloadJavadocs;
}
/**
* Setter for downloadJavadocs
.
*
* @param downloadJavadoc The downloadJavadocs to set.
*/
public void setDownloadJavadocs( boolean downloadJavadoc )
{
downloadJavadocs = downloadJavadoc;
}
/**
* Getter for downloadSources
.
*
* @return Returns the downloadSources.
*/
public boolean getDownloadSources()
{
return downloadSources;
}
/**
* Setter for downloadSources
.
*
* @param downloadSources The downloadSources to set.
*/
public void setDownloadSources( boolean downloadSources )
{
this.downloadSources = downloadSources;
}
protected void setResolveDependencies( boolean resolveDependencies )
{
this.resolveDependencies = resolveDependencies;
}
protected boolean isResolveDependencies()
{
return resolveDependencies;
}
/**
* return false
if projects available in a reactor build should be considered normal dependencies,
* true
if referenced project will be linked and not need artifact resolution.
*
* @return true
if referenced project will be linked and not need artifact resolution
*/
protected abstract boolean getUseProjectReferences();
/**
* Hook for preparation steps before the actual plugin execution.
*
* @return true
if execution should continue or false
if not.
* @throws MojoExecutionException generic mojo exception
*/
protected abstract boolean setup()
throws MojoExecutionException;
/**
* Main plugin method where dependencies should be processed in order to generate IDE configuration files.
*
* @param deps list of IdeDependency
objects, with artifacts, sources and javadocs already resolved
* @throws MojoExecutionException generic mojo exception
*/
protected abstract void writeConfiguration( IdeDependency[] deps )
throws MojoExecutionException;
/**
* Not a plugin parameter. Collect the list of dependencies with a missing source artifact for the final report.
*/
private List missingSourceDependencies = new ArrayList();
/**
* Not a plugin parameter. Collect the list of dependencies with a missing javadoc artifact for the final report.
*/
// TODO merge this with the missingSourceDependencies in a classifier based map?
private List missingJavadocDependencies = new ArrayList();
/**
* Cached array of resolved dependencies.
*/
private IdeDependency[] ideDeps;
/**
* Flag for mojo implementations to control whether normal maven dependencies should be resolved. Default value is
* true.
*/
private boolean resolveDependencies = true;
/**
* @see org.codehaus.plexus.logging.LogEnabled#enableLogging(org.codehaus.plexus.logging.Logger)
*/
public void enableLogging( Logger logger )
{
this.logger = logger;
}
/**
* @see org.apache.maven.plugin.Mojo#execute()
*/
public final void execute()
throws MojoExecutionException, MojoFailureException
{
if ( skip )
{
return;
}
boolean processProject = setup();
if ( !processProject )
{
return;
}
// resolve artifacts
IdeDependency[] deps = doDependencyResolution();
resolveSourceAndJavadocArtifacts( deps );
writeConfiguration( deps );
reportMissingArtifacts();
}
/**
* Resolve project dependencies. Manual resolution is needed in order to avoid resolution of multiproject artifacts
* (if projects will be linked each other an installed jar is not needed) and to avoid a failure when a jar is
* missing.
*
* @throws MojoExecutionException if dependencies can't be resolved
* @return resolved IDE dependencies, with attached jars for non-reactor dependencies
*/
protected IdeDependency[] doDependencyResolution()
throws MojoExecutionException
{
if ( ideDeps == null )
{
if ( resolveDependencies )
{
MavenProject project = getProject();
Setresolved
property set to true.
*
* @return list of projects artifacts
* @throws MojoExecutionException if unable to parse dependency versions
*/
private Set getProjectArtifacts()
throws MojoExecutionException
{
// keep it sorted, this should avoid random classpath order in tests
Set artifacts = new TreeSet();
for ( Iterator dependencies = getProject().getDependencies().iterator(); dependencies.hasNext(); )
{
Dependency dependency = (Dependency) dependencies.next();
String groupId = dependency.getGroupId();
String artifactId = dependency.getArtifactId();
VersionRange versionRange;
try
{
versionRange = VersionRange.createFromVersionSpec( dependency.getVersion() );
}
catch ( InvalidVersionSpecificationException e )
{
throw new MojoExecutionException(
Messages.getString(
"AbstractIdeSupportMojo.unabletoparseversion", new Object[] { //$NON-NLS-1$
dependency.getArtifactId(),
dependency.getVersion(),
dependency.getManagementKey(), e.getMessage() } ),
e );
}
String type = dependency.getType();
if ( type == null )
{
type = Constants.PROJECT_PACKAGING_JAR;
}
String classifier = dependency.getClassifier();
boolean optional = dependency.isOptional();
String scope = dependency.getScope();
if ( scope == null )
{
scope = Artifact.SCOPE_COMPILE;
}
Artifact art =
getArtifactFactory().createDependencyArtifact( groupId, artifactId, versionRange, type, classifier,
scope, optional );
if ( scope.equalsIgnoreCase( Artifact.SCOPE_SYSTEM ) )
{
art.setFile( new File( dependency.getSystemPath() ) );
}
List exclusions = new ArrayList();
for ( Iterator j = dependency.getExclusions().iterator(); j.hasNext(); )
{
Exclusion e = (Exclusion) j.next();
exclusions.add( e.getGroupId() + ":" + e.getArtifactId() ); //$NON-NLS-1$
}
ArtifactFilter newFilter = new ExcludesArtifactFilter( exclusions );
art.setDependencyFilter( newFilter );
artifacts.add( art );
}
return artifacts;
}
/**
* Utility method that locates a project producing the given artifact.
*
* @param artifact the artifact a project should produce.
* @return true
if the artifact is produced by a reactor projectart.
*/
protected boolean isAvailableAsAReactorProject( Artifact artifact )
{
return getReactorProject( artifact ) != null;
}
/**
* Checks the list of reactor projects to see if the artifact is included.
*
* @param artifact the artifact to check if it is in the reactor
* @return the reactor project or null if it is not in the reactor
*/
protected MavenProject getReactorProject( Artifact artifact ) {
if ( reactorProjects != null )
{
for ( Iterator iter = reactorProjects.iterator(); iter.hasNext(); )
{
MavenProject reactorProject = (MavenProject) iter.next();
if ( reactorProject.getGroupId().equals( artifact.getGroupId() )
&& reactorProject.getArtifactId().equals( artifact.getArtifactId() ) )
{
if ( reactorProject.getVersion().equals( artifact.getVersion() ) )
{
return reactorProject;
}
else
{
getLog().info(
"Artifact "
+ artifact.getId()
+ " already available as a reactor project, but with different version. Expected: "
+ artifact.getVersion() + ", found: " + reactorProject.getVersion() );
}
}
}
}
return null;
}
/**
* @return an array with all dependencies avalaible in the workspace, to be implemented by the subclasses.
*/
protected IdeDependency[] getWorkspaceArtefacts()
{
return new IdeDependency[0];
}
private Map createManagedVersionMap( ArtifactFactory artifactFactory, String projectId,
DependencyManagement dependencyManagement )
throws MojoExecutionException
{
Map map;
if ( dependencyManagement != null && dependencyManagement.getDependencies() != null )
{
map = new HashMap();
for ( Iterator i = dependencyManagement.getDependencies().iterator(); i.hasNext(); )
{
Dependency d = (Dependency) i.next();
try
{
VersionRange versionRange = VersionRange.createFromVersionSpec( d.getVersion() );
Artifact artifact =
artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(), versionRange,
d.getType(), d.getClassifier(), d.getScope(),
d.isOptional() );
map.put( d.getManagementKey(), artifact );
}
catch ( InvalidVersionSpecificationException e )
{
throw new MojoExecutionException( Messages.getString( "AbstractIdeSupportMojo.unabletoparseversion", new Object[] { //$NON-NLS-1$
projectId, d.getVersion(),
d.getManagementKey(), e.getMessage() } ),
e );
}
}
}
else
{
map = Collections.EMPTY_MAP;
}
return map;
}
/**
* Resolve source artifacts and download them if downloadSources
is true
. Source and
* javadocs artifacts will be attached to the IdeDependency
Resolve source and javadoc artifacts. The
* resolved artifacts will be downloaded based on the downloadSources
and downloadJavadocs
* attributes. Source and
*
* @param deps resolved dependencies
*/
private void resolveSourceAndJavadocArtifacts( IdeDependency[] deps )
{
final List missingSources =
resolveDependenciesWithClassifier( deps, "sources", getDownloadSources() );
missingSourceDependencies.addAll( missingSources );
final List missingJavadocs =
resolveDependenciesWithClassifier( deps, "javadoc", getDownloadJavadocs() );
missingJavadocDependencies.addAll( missingJavadocs );
}
/**
* Resolve the required artifacts for each of the dependency. sources
or javadoc
artifacts
* (depending on the classifier
) are attached to the dependency.
*
* @param deps resolved dependencies
* @param inClassifier the classifier we are looking for (either sources
or javadoc
)
* @param includeRemoteRepositories flag whether we should search remote repositories for the artifacts or not
* @return the list of dependencies for which the required artifact was not found
*/
private List resolveDependenciesWithClassifier( IdeDependency[] deps, String inClassifier,
boolean includeRemoteRepositories )
{
List missingClassifierDependencies = new ArrayList();
// if downloadSources is off, just check
// local repository for reporting missing source jars
List remoteRepos = includeRemoteRepositories ? getRemoteArtifactRepositories() : Collections.EMPTY_LIST;
for ( int j = 0; j < deps.length; j++ )
{
IdeDependency dependency = deps[j];
if ( dependency.isReferencedProject() || dependency.isSystemScoped() )
{
// artifact not needed
continue;
}
if ( getLog().isDebugEnabled() )
{
getLog().debug(
"Searching for sources for " + dependency.getId() + ":" + dependency.getClassifier()
+ " at " + dependency.getId() + ":" + inClassifier );
}
Artifact baseArtifact =
artifactFactory.createArtifactWithClassifier( dependency.getGroupId(), dependency.getArtifactId(),
dependency.getVersion(), dependency.getType(),
dependency.getClassifier() );
baseArtifact =
IdeUtils.resolveArtifact( artifactResolver, baseArtifact, remoteRepos, localRepository, getLog() );
if (!baseArtifact.isResolved()) {
// base artifact does not exist - no point checking for javadoc/sources
continue;
}
Artifact artifact =
IdeUtils.createArtifactWithClassifier( dependency.getGroupId(), dependency.getArtifactId(),
dependency.getVersion(), dependency.getClassifier(),
inClassifier, artifactFactory );
File notAvailableMarkerFile = IdeUtils.getNotAvailableMarkerFile( localRepository, artifact );
if (forceRecheck && notAvailableMarkerFile.exists()) {
if (!notAvailableMarkerFile.delete()) {
getLog().warn( Messages.getString( "AbstractIdeSupportMojo.unabletodeletenotavailablemarkerfile", notAvailableMarkerFile ) );
}
}
if ( !notAvailableMarkerFile.exists() )
{
artifact =
IdeUtils.resolveArtifact( artifactResolver, artifact, remoteRepos, localRepository, getLog() );
if ( artifact.isResolved() )
{
if ( "sources".equals( inClassifier ) )
{
dependency.setSourceAttachment( artifact.getFile() );
}
else if ( "javadoc".equals( inClassifier ) )
{
dependency.setJavadocAttachment( artifact.getFile() );
}
}
else
{
if ( includeRemoteRepositories )
{
try
{
notAvailableMarkerFile.createNewFile();
getLog().debug( Messages.getString( "AbstractIdeSupportMojo.creatednotavailablemarkerfile", notAvailableMarkerFile ) );
}
catch ( IOException e )
{
getLog().warn( Messages.getString( "AbstractIdeSupportMojo.failedtocreatenotavailablemarkerfile",
notAvailableMarkerFile ) );
}
}
// add the dependencies to the list
// of those lacking the required
// artifact
missingClassifierDependencies.add( dependency );
}
}
}
// return the list of dependencies missing the
// required artifact
return missingClassifierDependencies;
}
/**
* Output a message with the list of missing dependencies and info on how turn download on if it was disabled.
*/
private void reportMissingArtifacts()
{
StringBuffer msg = new StringBuffer();
if ( !missingSourceDependencies.isEmpty() )
{
if ( getDownloadSources() )
{
msg.append( Messages.getString( "AbstractIdeSupportMojo.sourcesnotavailable" ) ); //$NON-NLS-1$
}
else
{
msg.append( Messages.getString( "AbstractIdeSupportMojo.sourcesnotdownloaded" ) ); //$NON-NLS-1$
}
for ( Iterator it = missingSourceDependencies.iterator(); it.hasNext(); )
{
IdeDependency art = (IdeDependency) it.next();
msg.append( Messages.getString( "AbstractIdeSupportMojo.sourcesmissingitem", art.getId() ) ); //$NON-NLS-1$
}
msg.append( "\n" ); //$NON-NLS-1$
}
if ( !missingJavadocDependencies.isEmpty() )
{
if ( getDownloadJavadocs() )
{
msg.append( Messages.getString( "AbstractIdeSupportMojo.javadocnotavailable" ) ); //$NON-NLS-1$
}
else
{
msg.append( Messages.getString( "AbstractIdeSupportMojo.javadocnotdownloaded" ) ); //$NON-NLS-1$
}
for ( Iterator it = missingJavadocDependencies.iterator(); it.hasNext(); )
{
IdeDependency art = (IdeDependency) it.next();
msg.append( Messages.getString( "AbstractIdeSupportMojo.javadocmissingitem", art.getId() ) ); //$NON-NLS-1$
}
msg.append( "\n" ); //$NON-NLS-1$
}
getLog().info( msg );
}
/**
* @return List of dependencies to exclude from eclipse classpath.
* @since 2.5
*/
public abstract List getExcludes();
/**
* Checks if jar has to be resolved for the given artifact
*
* @param art the artifact to check
* @return true if resolution should happen
*/
protected boolean hasToResolveJar( Artifact art )
{
return !( getUseProjectReferences() && isAvailableAsAReactorProject( art ) );
}
/**
* Checks if a projects reference has to be used for the given artifact
*
* @param art the artifact to check
* @return true if a project reference has to be used.
*/
protected boolean useProjectReference( Artifact art )
{
return getUseProjectReferences() && isAvailableAsAReactorProject( art );
}
/**
* Checks whether the currently running Maven satisfies the specified version (range).
*
* @param version The version range to test for, must not be null
.
* @return true
if the current Maven version matches the specified version range, false
* otherwise.
*/
protected boolean isMavenVersion( String version )
{
try
{
VersionRange versionRange = VersionRange.createFromVersionSpec( version );
ArtifactVersion mavenVersion = runtimeInformation.getApplicationVersion();
return versionRange.containsVersion( mavenVersion );
}
catch ( InvalidVersionSpecificationException e )
{
throw new IllegalArgumentException( e.getMessage() );
}
}
// [rfeng]
protected boolean isOSGiBundle() {
File base = project.getBasedir();
File mf = new File(base, "META-INF/MANIFEST.MF");
if (mf.isFile()) {
Manifest manifest = null;
try {
InputStream is = new FileInputStream(mf);
manifest = new Manifest(is);
is.close();
} catch (IOException e) {
// Ignore
}
if (manifest != null) {
String bundleName = manifest.getMainAttributes().getValue("Bundle-SymbolicName");
if (bundleName != null) {
return true;
}
}
}
return false;
}
}