Hi Devs
//i could not get gmaven-runtime-loader for provider to work with
org.codehaus.groovy.maven.runtime.loader.DefaultProviderManager
//i made the following modifications to
target\classes\META-INF\plexus\component.xml to implement
org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactProviderLoader
//instead
<component>
<role>org.codehaus.groovy.maven.feature.ProviderManager</role>
<!--
implementation>org.codehaus.groovy.maven.runtime.loader.DefaultProviderManager</implementation
-->
<implementation>org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactProviderLoader</implementation>
<description>Default {@link ProviderManager}.</description>
<isolated-realm>false</isolated-realm>
<requirements>
<requirement>
<role>org.codehaus.groovy.maven.feature.ProviderRegistry</role>
<field-name>registry</field-name>
</requirement>
<requirement>
<role>org.codehaus.groovy.maven.feature.ProviderSelector</role>
<field-name>selector</field-name>
</requirement>
</requirements>
</component>
//this updated
org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactProviderLoader does
generate the new Implementor for org.codehaus.groovy.maven.feature.Provider
/*
* Copyright (C) 2006-2007 the original author or authors.
*
* Licensed 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.codehaus.groovy.maven.runtime.loader.artifact;
import org.apache.commons.lang.time.StopWatch;
import org.codehaus.groovy.maven.feature.ProviderRegistry;
import org.codehaus.groovy.maven.feature.ProviderSelector;
import org.codehaus.groovy.maven.feature.ProviderException;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
import org.codehaus.groovy.maven.feature.Provider;
import org.codehaus.groovy.maven.feature.ProviderLoader;
import org.codehaus.groovy.maven.runtime.loader.realm.RealmManager;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactHandler;
/**
* Loads a provider based on a configured {@link ArtifactHandler}.
*
* @plexus.component role="org.codehaus.groovy.maven.feature.ProviderLoader"
role-hint="artifact"
*
* @version $Id: ArtifactProviderLoader.java 13498 2008-09-09 05:09:10Z user57 $
* @author <a href="mailto:ja...@planet57.com";>Jason Dillon</a>
*/
public class ArtifactProviderLoader implements ProviderLoader,
org.codehaus.groovy.maven.feature.ProviderManager,
ArtifactHandler
{
public org.apache.maven.artifact.resolver.filter.ArtifactFilter filter=null;
public org.apache.maven.artifact.resolver.ArtifactResolutionResult
result=null;
public org.apache.maven.artifact.Artifact artifact=null;
public String query=null;
public org.apache.maven.artifact.Artifact createQuery(String s)
{
this.query=s;
return artifact;
}
public org.apache.maven.artifact.Artifact
createDependency(org.apache.maven.artifact.Artifact artifact)
{
this.artifact=artifact;
return this.artifact;
}
public org.apache.maven.artifact.resolver.ArtifactResolutionResult
resolve(org.apache.maven.artifact.Artifact
artifact,org.apache.maven.artifact.resolver.filter.ArtifactFilter filter)
{
this.filter=filter;
if(this.filter==null) filter =
(org.apache.maven.artifact.resolver.filter.ArtifactFilter)new
ScopeArtifactFilter(DefaultArtifact.SCOPE_RUNTIME);
return result;
}
public Provider select(final String selection)
{
assert selection != null;
System.out.println("ArtifactProviderLoader::select(selection="+selection+")
where provider="+getProvider());
if(getProvider()==null)
{
System.out.println("ArtifactProviderLoader::select(selection)
provider is null");
setProvider((Provider) cachedSelection.get(selection));
}
if (getProvider() != null)
{
log.debug("Using cached provider '{}' for selection: {}",
getProvider(), selection);
}
else
{
log.debug("Selecting provider; selection: {}", selection);
StopWatch watch = new StopWatch();
watch.start();
if(getProvider()==null)
{
try
{
setProvider(getSelector().select(getRegistry(), selection));
}
catch (Exception e)
{
setProvider((org.codehaus.groovy.maven.feature.Provider)new
org.codehaus.groovy.maven.runtime.ProviderImpl());
}
}
if(getProvider()==null)
{
Map m=null;
Provider p=null;
try {
m=load(selection);
p=(Provider)m.get(selection);
}
catch(Exception excp)
{
}
if(p!=null)
{
System.out.println("ArtifactProviderLoader::select about to
set provider="+p);
setProvider(p);
}
}
if(getProvider()==null)
{
System.out.println("ArtifactProviderLoader::select
getProvider() returns null where selection="+selection);
Map m=null;
try {
load(selection);
}
catch(Exception excp)
{
}
System.out.println("ArtifactProviderLoader::select
getProvider() asfter load(selection) where returned map="+m);
org.codehaus.groovy.maven.runtime.v1_0_rc_5.ProviderImpl
impl=new org.codehaus.groovy.maven.runtime.v1_0_rc_5.ProviderImpl();
org.codehaus.groovy.maven.feature.Provider
p=(org.codehaus.groovy.maven.feature.Provider)impl;
System.out.println("ArtifactProviderLoader::select after
m.get(selection) where provider="+p);
if(p!=null) setProvider(p);
}
System.out.println("ArtifactProviderLoader::select
selection="+selection+" provider="+getProvider());
if (getProvider() == null)
{
throw new
ProviderException("ArtifactProviderLoader:;select(selection) No providers found
matching selection: " + selection);
}
cachedSelection.put(selection, getProvider());
watch.stop();
log.debug("Selected provider: {} ({})", getProvider(), watch);
}
Provider prov= getProvider();
if(prov==null)
{
try {
prov=(Provider)load(selection).get(selection);
}
catch(Exception excp)
{
}
}
if(prov==null)
{
prov=(Provider)new org.codehaus.groovy.maven.runtime.ProviderImpl();
}
System.out.println("ArtifactProviderLoader::select returns
provider="+prov);
if(prov!=null)
{
System.out.println("ArtifactProviderLoader::select returns
prov="+prov);
setProvider(prov);
}
return prov;
}
public ProviderRegistry getRegistry() {
if (registry == null) {
throw new IllegalStateException("Registry not bound");
}
return registry;
}
public String getDefaultSelection() {
return ProviderSelector.SELECT_DEFAULT;
}
public ProviderSelector selector;
public ProviderRegistry registry;
public Map cachedSelection = new HashMap();
public Provider select() {
Provider p= select(getDefaultSelection());
if(getProvider()!=null) return getProvider();
else
{
setProvider(p);
}
return p;
}
public ProviderSelector getSelector() {
if (registry == null) {
throw new IllegalStateException("Selector not bound");
}
return selector;
}
private final Logger log = LoggerFactory.getLogger(getClass());
/**
* @plexus.requirement
*
* @noinspection UnusedDeclaration
*/
private RealmManager realmManager;
public ArtifactProviderLoader() {}
protected ArtifactHandler handler=null;
public ArtifactHandler getHandler() { return handler; }
public void setHandler(final ArtifactHandler handler) {
System.out.println("ArtifactProviderLoader:;setHandler handler="+handler);
this.handler = handler; }
protected Provider provider=null;
public Provider getProvider()
{
return provider;
}
public void setProvider(Provider p)
{
if(p!=null)
{
System.out.println("ArtifactProvider::setProvider provider="+p);
this.provider=p;
}
}
public Map load(final String key) throws Exception
{
assert key != null;
if(getHandler()==null) setHandler((ArtifactHandler)this);
System.out.println("ArtifactProviderLoader::load
handler="+getHandler());
if (getHandler() == null)
{
log.error("Artifact handler has not been configured; unable to load
anything");
return null;
}
System.out.println("ArtifactProviderLoader::load() before
loadProvider(key) key="+key);
//Provider provider = loadProvider(key);
//System.out.println("ArtifactProviderLoader::load provider="+provider);
setProviders(new HashMap());
System.out.println("ArtifactProviderLoader:load
providers="+getProviders());
org.codehaus.groovy.maven.runtime.v1_0_rc_5.ProviderImpl impl=new
org.codehaus.groovy.maven.runtime.v1_0_rc_5.ProviderImpl();
org.codehaus.groovy.maven.feature.Provider
p=(org.codehaus.groovy.maven.feature.Provider)impl;
System.out.println("ArtifactProviderLoader::load about to
getProviders().put(key,provider) where key="+key+" provider="+getProvider());
try
{
getProviders().put(getProvider().key(), getProvider());
System.out.println("ArtifactProviderLoader::load() returns
getProviders()="+getProviders());
}
catch(NullPointerException npe)
{
}
return getProviders();
}
protected Map providers;
public Map getProviders() { return this.providers; }
public void setProviders(Map map) { this.providers=map; }
private URL[] buildClassPath(final Artifact query) throws Exception
{
assert query != null;
System.out.println("ArtifactProviderLoader::buildClassPath
query="+query);
if(getHandler()==null) setHandler((ArtifactHandler)this);
Artifact artifact = getHandler().createDependency(query);
System.out.println("ArtifactProviderLoader::buildClassPath
artifact="+artifact);
System.out.println("ArtifactProviderLoader::buildClassPath befoe
handler.resolve artifact="+artifact);
ArtifactResolutionResult result = getHandler().resolve(artifact, new
ScopeArtifactFilter(DefaultArtifact.SCOPE_RUNTIME));
System.out.println("ArtifactProviderLoader::buildClassPath
result="+result);
List classPath = new ArrayList();
// Add runtime dependency classpath
System.out.println("ArtifactProviderLoader::buildClassPath before for
(Iterator iter = result.getArtifacts().iterator(); iter.hasNext();)");
for (Iterator iter = result.getArtifacts().iterator(); iter.hasNext();)
{
Artifact element = (Artifact) iter.next();
System.out.println("ArtifactProviderLoader:;buildClassPath
element="+element);
File file = element.getFile();
URL url = file.toURI().toURL();
System.out.println("ArtifactProviderLoader::buildClassPath about to
classPath.add(url) where url="+url);
classPath.add(url);
}
return (URL[]) classPath.toArray(new URL[classPath.size()]);
}
public Provider loadProvider(final String key) throws Exception
{
assert key != null;
log.debug("ArtifactProviderLoader::Loading providers: using key=", key);
if(getHandler()==null) setHandler((ArtifactHandler)this);
Artifact query = getHandler().createQuery(key);
URL[] classPath = buildClassPath(query);
ClassLoader parent = getClass().getClassLoader();
ClassRealm realm = realmManager.createProviderRealm(key, classPath,
parent);
Class type = realm.loadClass("org.codehaus.groovy.maven.runtime.v" +
key.replace('.', '_').replace('-', '_') + ".ProviderImpl");
Provider p= (Provider)type.newInstance();
System.out.println("ArtifactProviderLoader::loadProvider returning
provider="+p);
return p;
}
}
//implementor code org.codehaus.groovy.maven.runtime.v1_0_rc_5.ProviderImpl
//notice the hardcoded key of "1.0-rc-5"
/*
* Copyright (C) 2006-2007 the original author or authors.
*
* Licensed 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.codehaus.groovy.maven.runtime.v1_0_rc_5;
import org.codehaus.groovy.maven.feature.Configuration;
import org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactHandler;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
import org.codehaus.groovy.maven.feature.Provider;
import org.codehaus.groovy.maven.feature.ProviderLoader;
import org.codehaus.groovy.maven.runtime.loader.realm.RealmManager;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.groovy.maven.feature.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Loads a provider based on a configured {@link ArtifactHandler}.
*
* @plexus.component role="org.codehaus.groovy.maven.feature.ProviderLoadic er"
role-hint="artifact"
*
* @version $Id: ProviderImpl.java 13498 2008-09-09 05:09:10Z user57 $
* @author <a href="mailto:ja...@planet57.com";>Jason Dillon</a>
*/
public class ProviderImpl implements org.codehaus.groovy.maven.feature.Provider,
org.codehaus.groovy.maven.feature.Feature,
org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactHandler,
org.codehaus.groovy.maven.feature.Component, //ProviderLoader
org.codehaus.groovy.maven.runtime.ClassCompiler
{
private final Logger log = LoggerFactory.getLogger(getClass());
public ArrayList<java.net.URL> sources=new ArrayList();
public java.io.File directory=null;
public java.io.File getTargetDirectory()
{
while(sources.iterator().hasNext())
{
java.io.File test=(File)new
java.io.File(sources.iterator().next().getFile());
if(test.isDirectory()==true) return test;
}
return null;
}
public void setTargetDirectory(java.io.File file)
{
this.directory=file;
try {
sources.add(file.toURL());
}
catch(java.net.MalformedURLException excp)
{
System.out.println("MalformedURLException has been thrown
message="+excp.getMessage());
}
}
public java.util.Collection sources()
{
return this.sources;
}
public void add(File f)
{
try {
sources.add(f.toURL());
}
catch(Exception excp)
{
System.out.println("ProviderImpl::add throws Exception
message="+excp.getMessage());
}
}
public void add(URL source)
{
sources.add(source);
}
public int compile()
{
return 0;
}
public java.net.URL[] getClassPath()
{
try {
load("1.0-rc-5");
}
catch(Exception excp)
{
System.out.println("ProvideImpl::getClassPath() throws exception
message="+excp.getMessage());
}
return classPath;
}
public void setClassPath(java.net.URL[] nets)
{
this.classPath=nets;
}
public void selectClassPath(java.net.URL[] nets)
{
this.classPath=nets;
}
public ProviderImpl()
{
super();
try {
create();
}
catch(Exception excp)
{
}
}
public Component create(org.codehaus.groovy.maven.feature.Configuration
config)
{
this.config=config;
return (Component)this;
}
public Component create() throws Exception
{
return (Component)this;
}
/**
* @plexus.requirement
*
* @noinspection UnusedDeclaration
*/
private RealmManager realmManager;
private org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactHandler
handler=null;
public org.codehaus.groovy.maven.runtime.loader.artifact.ArtifactHandler
getHandler() {
return handler;
}
public void setHandler(final ArtifactHandler handler) {
System.out.println("ProviderImpl:;setHandler handler="+handler);
this.handler = handler;
}
public Map load(final String key) throws Exception {
assert key != null;
System.out.println("ProviderImpl::load handler="+handler);
if (handler == null) {
log.error("Artifact handler has not been configured; unable to load
anything");
return null;
}
System.out.println("ProviderImpl::load() key="+key);
Provider provider = loadProvider(key);
System.out.println("ProviderImpl::load provider="+provider);
Map providers = new HashMap();
System.out.println("ProviderImpl:load providers="+providers);
System.out.println("ProviderImpl::load about to
providers.put(key,provider) where key="+key+" provider="+provider);
providers.put(provider.key(), provider);
return providers;
}
public org.apache.maven.artifact.resolver.filter.ArtifactFilter filter=null;
public org.apache.maven.artifact.resolver.ArtifactResolutionResult
result=null;
public org.apache.maven.artifact.resolver.ArtifactResolutionResult
resolve(org.apache.maven.artifact.Artifact
artifact,org.apache.maven.artifact.resolver.filter.ArtifactFilter filter)
{
this.filter=filter;
if(this.filter==null) filter =
(org.apache.maven.artifact.resolver.filter.ArtifactFilter)new
ScopeArtifactFilter(DefaultArtifact.SCOPE_RUNTIME);
return result;
}
public org.apache.maven.artifact.Artifact artifact=null;
public String query=null;
public org.apache.maven.artifact.Artifact createQuery(String s)
{
this.query=s;
return artifact;
}
public org.apache.maven.artifact.Artifact
createDependency(org.apache.maven.artifact.Artifact artifact)
{
this.artifact=artifact;
return this.artifact;
}
private URL[] buildClassPath(final Artifact query) throws Exception
{
assert query != null;
System.out.println("ProviderImpl::buildClassPath query="+query);
Artifact artifact = handler.createDependency(query);
System.out.println("ProviderImpl::buildClassPath artifact="+artifact);
System.out.println("ProviderImpl::buildClassPath befoe handler.riesolve
artifact="+artifact);
filter = new ScopeArtifactFilter(DefaultArtifact.SCOPE_RUNTIME);
ArtifactResolutionResult result = handler.resolve(artifact, filter);
System.out.println("ProviderImpl::buildClassPath result="+result);
List classPath = new ArrayList();
// Add runtime dependency classpath
System.out.println("ProviderImpl::buildClassPath before for (Iterator
iter = result.getArtifacts().iterator(); iter.hasNext();)");
for (Iterator iter = result.getArtifacts().iterator(); iter.hasNext();)
{
Artifact element = (Artifact) iter.next();
System.out.println("ProviderImpl:;buildClassPath element="+element);
File file = element.getFile();
URL url = file.toURI().toURL();
System.out.println("ProviderImpl::buildClassPath about to
classPath.add(url) where url="+url);
classPath.add(url);
}
return (URL[]) classPath.toArray(new URL[classPath.size()]);
}
public URL[] classPath=null;
public String key="1.0-rc-5";
private Provider loadProvider(final String key) throws Exception {
assert key != null;
this.key=key;
log.debug("Loading providers: {}", key);
Artifact query = handler.createQuery(key);
classPath = buildClassPath(query);
ClassLoader parent = getClass().getClassLoader();
ClassRealm realm = realmManager.createProviderRealm(key, classPath,
parent);
type = realm.loadClass("org.codehaus.groovy.maven.runtime.v" +
key.replace('.', '_').replace('-', '_') + ".ProviderImpl");
return (Provider) type.newInstance();
}
public Class type=null;
public int feature_ctr=0;
public org.codehaus.groovy.maven.feature.Feature feature=null;
public org.codehaus.groovy.maven.feature.Feature feature()
{
return feature;
}
public ArrayList<org.codehaus.groovy.maven.feature.Feature> features=new
ArrayList();
public org.codehaus.groovy.maven.feature.Feature feature(Class c)
{
this.type=c;
feature=this;
features.add(feature);
return this;
}
public String key() { return this.name; }
public ArrayList<org.codehaus.groovy.maven.feature.Feature> features()
{
return this.features;
}
public String name="ProviderImpl";
public String name() { return this.name; }
public org.codehaus.groovy.maven.feature.Version version() { return new
org.codehaus.groovy.maven.feature.Version(1, 0, 5, "1.0-rc-5"); }
public boolean supported() { return true; }
public void require() { ; }
public Configuration config=null;
public Configuration config()
{
return config;
}
public static Class clazz=null;
public org.codehaus.groovy.maven.feature.Feature feature(String s)
{
try {
clazz=java.lang.Class.forName(s);
}
catch(ClassNotFoundException cnfe)
{
System.out.println("ProviderImpl::feature ClassNotFoundException
has been thrown message="+cnfe.getMessage());
return null;
}
this.type=clazz;
return (org.codehaus.groovy.maven.feature.Feature)this;
}
}
//use the hardcoded 1.0-rc-5 provider so anyone gets tripped up by the gmaven
provider registry please feel free to use this hardcoded implementor
test with
<project xmlns="http://maven.apache.org/POM/4.0.0";
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd";>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.seleniumhq.selenium.client-drivers</groupId>
<version>1.0.1</version>
<artifactId>selenium-client-drivers</artifactId>
</parent>
.....
<groupId>org.seleniumhq.selenium.client-drivers</groupId>
<artifactId>selenium-java-client-driver</artifactId>
<version>1.0.1</version>
....................
<build>
<plugins>
<plugin>
<groupId>org.codehaus.groovy.maven</groupId>
<artifactId>gmaven-plugin</artifactId>
<version>1.0-rc-5</version>
<configuration>
<providerSelection>1.0-rc-5</providerSelection>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>org.codehaus.groovy.maven.runtime</groupId>
<artifactId>gmaven-runtime-loader</artifactId>
<version>1.0-rc-5</version>
</dependency>
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-container-default</artifactId>
<version>1.0-alpha-9</version>
</dependency>
</dependencies>
</plugin>
...
</plugins>
</build>
</project>
Martin Gainty
______________________________________________
Verzicht und Vertraulichkeitanmerkung/Note de déni et de confidentialité
Diese Nachricht ist vertraulich. Sollten Sie nicht der vorgesehene Empfaenger
sein, so bitten wir hoeflich um eine Mitteilung. Jede unbefugte Weiterleitung
oder Fertigung einer Kopie ist unzulaessig. Diese Nachricht dient lediglich dem
Austausch von Informationen und entfaltet keine rechtliche Bindungswirkung.
Aufgrund der leichten Manipulierbarkeit von E-Mails koennen wir keine Haftung
fuer den Inhalt uebernehmen.
Ce message est confidentiel et peut être privilégié. Si vous n'êtes pas le
destinataire prévu, nous te demandons avec bonté que pour satisfaire informez
l'expéditeur. N'importe quelle diffusion non autorisée ou la copie de ceci est
interdite. Ce message sert à l'information seulement et n'aura pas n'importe
quel effet légalement obligatoire. Étant donné que les email peuvent facilement
être sujets à la manipulation, nous ne pouvons accepter aucune responsabilité
pour le contenu fourni.
