import java.lang.reflect.Constructor;

import org.openide.modules.Dependency;

import org.openide.modules.SpecificationVersion;

import org.netbeans.core.modules.ModuleManager;

                // #14722: pay attention also to META-INF/services/class.Name resources:

                createMetaInfServicesLookup(false),

        /** @param modules if true, use module classloader, else not */

        private static Lookup createMetaInfServicesLookup(boolean modules) {

            try {

                Class clazz = Class.forName("org.openide.util.MetaInfServicesLookup"); // NOI18N

                Constructor c = clazz.getDeclaredConstructor(new Class[] {ClassLoader.class});

                c.setAccessible(true);

                ClassLoader loader;

                if (modules) {

                    loader = get().getModuleSystem().getManager().getClassLoader();

                } else {

                    loader = Lkp.class.getClassLoader();

                }

                return (Lookup)c.newInstance(new Object[] {loader});

            } catch (Exception e) {

                e.printStackTrace();

                return Lookup.EMPTY;

            }

        }

                        old[1], // metaInfServicesLookup

                    // Also listen for changes in modules, as META-INF/services/ would change:

                    get().getModuleSystem().getManager().addPropertyChangeListener(new ConvertorListener());

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.util;

import java.net.URL;

import java.util.*;

import java.io.*;

import org.openide.ErrorManager;

import org.openide.util.lookup.*;

/** A lookup that implements the JDK1.3 JAR services mechanism and delegates

 * to META-INF/services/name.of.class files.

 * <p>It is not dynamic - so if you need to change the classloader or JARs,

 * wrap it in a ProxyLookup and change the delegate when necessary.

 * Existing instances will be kept if the implementation classes are unchanged,

 * so there is "stability" in doing this provided some parent loaders are the same

 * as the previous ones.

 * <p>If this is to be made public, please move it to the org.openide.util.lookup

 * package; currently used by the core via reflection, until it is needed some

 * other way.

 * @author Jaroslav Tulach, Jesse Glick

 * @see #14722

 */

final class MetaInfServicesLookup extends AbstractLookup {

    private static final Map knownInstances = new WeakHashMap(); // Map<Class,Object>

    /** A set of all requested classes.

     * Note that classes that we actually succeeded on can never be removed

     * from here because we hold a strong reference to the loader.

     * However we also hold classes which are definitely not loadable by

     * our loader.

     */

    private final Set classes = new WeakSet(); // Set<Class>

    /** class loader to use */

    private final ClassLoader loader;

    /** Create a lookup reading from the classpath.

     * That is, the same classloader as this class itself.

     */

    public MetaInfServicesLookup() {

        this(MetaInfServicesLookup.class.getClassLoader());

    }

    /** Create a lookup reading from a specified classloader.

     */

    public MetaInfServicesLookup(ClassLoader loader) {

        this.loader = loader;

    }

    /* Tries to load appropriate resources from manifest files.

     */

    protected synchronized final void beforeLookup(Lookup.Template t) {

        Class c = t.getType();

        if (classes.add(c)) {

            // Added new class, search for it.

            List arr = new ArrayList();

            search(c, arr);

            Iterator it = arr.iterator();

            while (it.hasNext()) {

                Pair p = (Pair)it.next();

                addPair(p);

            }

        }

    }

    /** Finds all pairs and adds them to the collection.

     *

     * @param clazz class to find

     * @param result collection to add Pair to

     */

    private void search(Class clazz, Collection result) {

        String res = "META-INF/services/" + clazz.getName(); // NOI18N

        Enumeration en;

        try {

            en = loader.getResources(res);

        } catch (IOException ioe) {

            ErrorManager.getDefault().notify(ioe);

            return;

        }

        // Do not create multiple instances in case more than one JAR

        // has the same entry in it (and they load to the same class).

        // Probably would not happen, assuming JARs only list classes

        // they own, but just in case...

        Set foundClasses = new HashSet(); // Set<Class>

        boolean foundOne = false;

        while (en.hasMoreElements()) {

            if (!foundOne) {

                foundOne = true;

                // Double-check that in fact we can load the *interface* class.

                // For example, say class I is defined in two JARs, J1 and J2.

                // There is also an implementation M1 defined in J1, and another

                // implementation M2 defined in J2.

                // Classloaders C1 and C2 are made from J1 and J2.

                // A MetaInfServicesLookup is made from C1. Then the user asks to

                // lookup I as loaded from C2. J1 has the services line and lists

                // M1, and we can in fact make it. However it is not of the desired

                // type to be looked up. Don't do this check, which could be expensive,

                // unless we expect to be getting some results, however.

                Class realMcCoy = null;

                try {

                    realMcCoy = loader.loadClass(clazz.getName());

                } catch (ClassNotFoundException cnfe) {

                    // our loader does not know about it, OK

                }

                if (realMcCoy != clazz) {

                    // Either the interface class is not available at all in our loader,

                    // or it is not the same version as we expected. Don't provide results.

                    return;

                }

            }

            URL url = (URL)en.nextElement();

            try {

                InputStream is = url.openStream();

                try {

                    BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); // NOI18N

                    while (true) {

                        String line = reader.readLine();

                        if (line == null) break;

                        // Ignore blank lines and comments.

                        line = line.trim();

                        if (line.length() == 0) continue;

                        if (line.charAt(0) == '#') continue; // NOI18N

                        // Most lines are fully-qualified class names.

                        Class inst = Class.forName(line, false, loader);

                        if (!clazz.isAssignableFrom(inst)) {

                            throw new ClassNotFoundException(inst.getName() + " not a subclass of " + clazz.getName()); // NOI18N

                        }

                        if (foundClasses.add(inst)) {

                            result.add(new P(inst));

                        }

                    }

                } finally {

                    is.close();

                }

            } catch (ClassNotFoundException ex) {

                ErrorManager.getDefault().notify(ex);

            } catch (IOException ex) {

                ErrorManager.getDefault().notify(ex);

            }

        }

    }

    /** Pair that holds name of a class and maybe the instance.

     */

    private static final class P extends Pair {

        /** May be one of three things:

         * 1. The implementation class which was named in the services file.

         * 2. An instance of it.

         * 3. Null, if creation of the instance resulted in an error.

         */

        private Object object;

        public P(Class clazz) {

            this.object = clazz;

        }

        /** Finds the class.

         */

        private Class clazz() {

            Object o = object;

            if (o instanceof Class) {

                return (Class)o;

            } else if (o != null) {

                return o.getClass();

            } else {

                // Broken.

                return Object.class;

            }

        }

        public boolean equals(Object o) {

            if (o instanceof P) {

                return ((P)o).clazz().equals(clazz());

            }

            return false;

        }

        public int hashCode() {

            return clazz().hashCode();

        }

        protected boolean instanceOf(Class c) {

            return c.isAssignableFrom(clazz());

        }

        public Class getType() {

            return clazz();

        }

        public Object getInstance() {

            synchronized (knownInstances) {

                if (object instanceof Class) {

                    try {

                        Class c = ((Class)object);

                        object = knownInstances.get(c);

                        if (object == null) {

                            object = c.newInstance();

                            knownInstances.put(c, object);

                        }

                    } catch (Exception ex) {

                        ErrorManager.getDefault().notify(ex);

                        object = null;

                    }

                }

                return object;

            }

        }

        public String getDisplayName() {

            return clazz().getName();

        }

        public String getId() {

            return clazz().getName();

        }

        protected boolean creatorOf(Object obj) {

            return obj == object;

        }

    }

}

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.core.lookup;

import org.netbeans.junit.*;

import junit.textui.TestRunner;

import org.netbeans.core.NbTopManager;

import org.netbeans.core.modules.*;

import org.openide.TopManager;

import org.openide.util.*;

import java.io.File;

import java.util.*;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.SAXParserFactory;

/** Test whether modules can really register things in their META-INF/services/class.Name

 * files, and whether this behaves correctly when the modules are disabled/enabled.

 * Note that Plain loads its classpath modules as soon as you ask for it, so these

 * tests do not check what happens on the NetBeans startup classpath.

 * @author Jesse Glick

 */

public class MetaInfServicesTest extends NbTestCase {

    public MetaInfServicesTest(String name) {

        super(name);

    }

    public static void main(String[] args) throws Exception {

        File temp = File.createTempFile("MetaInfServicesTest", ".dummy");

        System.setProperty("nbjunit.workdir", new File(temp.getParentFile(), temp.getName().substring(0, temp.getName().length() - 6)).getAbsolutePath());

        TestRunner.run(new NbTestSuite(MetaInfServicesTest.class));

    }

    private ModuleManager mgr;

    private Module m1, m2;

    protected void setUp() throws Exception {

        //System.err.println("setUp");

        //Thread.dumpStack();

        clearWorkDir();

        // Load Plain.

        TopManager.getDefault();

        // Make a couple of modules.

        mgr = NbTopManager.get().getModuleSystem().getManager();

        try {

            mgr.mutex().writeAccess(new Mutex.ExceptionAction() {

                public Object run() throws Exception {

                    File jar1 = new File(MetaInfServicesTest.class.getResource("data/services-jar-1.jar").getPath());

                    File jar2 = new File(MetaInfServicesTest.class.getResource("data/services-jar-2.jar").getPath());

                    m1 = mgr.create(jar1, new ModuleHistory(), false, false, false);

                    m2 = mgr.create(jar2, new ModuleHistory(), false, false, false);

                    return null;

                }

            });

        } catch (MutexException me) {

            throw me.getException();

        }

        assertEquals(Collections.EMPTY_SET, m1.getProblems());

    }

    protected void tearDown() throws Exception {

        try {

            mgr.mutex().writeAccess(new Mutex.ExceptionAction() {

                public Object run() throws Exception {

                    if (m2.isEnabled()) mgr.disable(m2);

                    mgr.delete(m2);

                    if (m1.isEnabled()) mgr.disable(m1);

                    mgr.delete(m1);

                    return null;

                }

            });

        } catch (MutexException me) {

            throw me.getException();

        }

        m1 = null;

        m2 = null;

        mgr = null;

    }

    protected static final int TWIDDLE_ENABLE = 0;

    protected static final int TWIDDLE_DISABLE = 1;

    protected void twiddle(final Module m, final int action) throws Exception {

        try {

            mgr.mutex().writeAccess(new Mutex.ExceptionAction() {

                public Object run() throws Exception {

                    switch (action) {

                    case TWIDDLE_ENABLE:

                        mgr.enable(m);

                        break;

                    case TWIDDLE_DISABLE:

                        mgr.disable(m);

                        break;

                    default:

                        throw new IllegalArgumentException("bad action: " + action);

                    }

                    return null;

                }

            });

        } catch (MutexException me) {

            throw me.getException();

        }

    }

    /** Fails to work if you have >1 method per class, because setUp gets run more

     * than once (XTest bug I suppose).

     */

    public void testEverything() throws Exception {

        twiddle(m1, TWIDDLE_ENABLE);

        Class xface = TopManager.getDefault().systemClassLoader().loadClass("org.foo.Interface");

        Lookup.Result r = Lookup.getDefault().lookup(new Lookup.Template(xface));

        List instances = new ArrayList(r.allInstances());

        // Expect to get Impl1 from first JAR.

        assertEquals(1, instances.size());

        Object instance1 = instances.get(0);

        assertTrue(xface.isInstance(instance1));

        assertEquals("org.foo.impl.Implementation1", instance1.getClass().getName());

        // Expect to have (same) Impl1 + Impl2.

        LookupL l = new LookupL();

        r.addLookupListener(l);

        twiddle(m2, TWIDDLE_ENABLE);

        assert(l.gotSomething());

        instances = new ArrayList(r.allInstances());

        assertEquals(2, instances.size());

        assertEquals(instance1, instances.get(0));

        assertEquals("org.bar.Implementation2", instances.get(1).getClass().getName());

        // Expect to lose Impl2.

        l.count = 0;

        twiddle(m2, TWIDDLE_DISABLE);

        assert(l.gotSomething());

        instances = new ArrayList(r.allInstances());

        assertEquals(1, instances.size());

        assertEquals(instance1, instances.get(0));

        // Expect to lose Impl1 too.

        l.count = 0;

        twiddle(m1, TWIDDLE_DISABLE);

        assert(l.gotSomething());

        instances = new ArrayList(r.allInstances());

        assertEquals(0, instances.size());

        // Expect to not get anything: wrong xface version

        l.count = 0;

        twiddle(m1, TWIDDLE_ENABLE);

        // not really important: assert(!l.gotSomething());

        instances = new ArrayList(r.allInstances());

        assertEquals(0, instances.size());

        Class xface2 = TopManager.getDefault().systemClassLoader().loadClass("org.foo.Interface");

        assertTrue(xface != xface2);

        Lookup.Result r2 = Lookup.getDefault().lookup(new Lookup.Template(xface2));

        instances = new ArrayList(r2.allInstances());

        assertEquals(1, instances.size());

        // Let's also check up on XML providers, which ought to be in the classpath.

        DocumentBuilderFactory dbf = (DocumentBuilderFactory)Lookup.getDefault().lookup(DocumentBuilderFactory.class);

        assertNotNull(dbf);

        SAXParserFactory spf = (SAXParserFactory)Lookup.getDefault().lookup(SAXParserFactory.class);

        assertNotNull(spf);

        //System.err.println("dbf=" + dbf + " spf=" + spf);

        //System.err.println("all DBFs=" + Lookup.getDefault().lookup(new Lookup.Template(DocumentBuilderFactory.class)).allInstances());

    }

    protected static final class LookupL implements LookupListener {

        public int count = 0;

        public synchronized void resultChanged(LookupEvent ev) {

            count++;

            notifyAll();

        }

        public synchronized boolean gotSomething() throws InterruptedException {

            if (count > 0) return true;

            wait(9999);

            return count > 0;

        }

    }

}

    <target name="services1">

        <javac srcdir="services-jar-1" destdir="services-jar-1"/>

        <jar jarfile="services-jar-1.jar" manifest="services-jar-1.mf">

            <fileset dir="services-jar-1"/>

        </jar>

    </target>

    <target name="services2" depends="services1">

        <javac srcdir="services-jar-2" destdir="services-jar-2" classpath="services-jar-1.jar"/>

        <jar jarfile="services-jar-2.jar" manifest="services-jar-2.mf">

            <fileset dir="services-jar-2"/>

        </jar>

    </target>

Manifest-Version: 1.0

OpenIDE-Module: org.foo

OpenIDE-Module-Name: Interface & Impl #1

OpenIDE-Module-IDE-Dependencies: IDE/1 > 2.2

Manifest-Version: 1.0

OpenIDE-Module: org.bar

OpenIDE-Module-Name: Impl #2

OpenIDE-Module-Module-Dependencies: org.foo

OpenIDE-Module-IDE-Dependencies: IDE/1 > 2.2

# Some header info, maybe.

# Our first impl here:

org.foo.impl.Implementation1

package org.foo;

public interface Interface {}

package org.foo.impl;

import org.foo.Interface;

public class Implementation1 implements Interface {}

org.bar.Implementation2

package org.bar;

import org.foo.Interface;

public class Implementation2 implements Interface {}

       <ant dir="unit/src/org/openide/util/data"/>

       <ant dir="unit/src/org/openide/util/data" target="clean"/>

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.util;

import org.netbeans.junit.*;

import junit.textui.TestRunner;

import java.net.*;

import java.util.*;

/** Test finding services from manifest.

 * @author Jesse Glick

 */

public class MetaInfServicesLookupTest extends NbTestCase {

    public MetaInfServicesLookupTest(String name) {

        super(name);

    }

    public static void main(String[] args) {

        TestRunner.run(new NbTestSuite(MetaInfServicesLookupTest.class));

    }

    ClassLoader c1, c2, c2a, c3, c4;

    protected void setUp() throws Exception {

        c1 = new URLClassLoader(new URL[] {

            MetaInfServicesLookupTest.class.getResource("data/services-jar-1.jar"),

        });

        c2 = new URLClassLoader(new URL[] {

            MetaInfServicesLookupTest.class.getResource("data/services-jar-2.jar"),

        }, c1);

        c2a = new URLClassLoader(new URL[] {

            MetaInfServicesLookupTest.class.getResource("data/services-jar-2.jar"),

        }, c1);

        c3 = new URLClassLoader(new URL[] {

            MetaInfServicesLookupTest.class.getResource("data/services-jar-2.jar"),

        });

        c4 = new URLClassLoader(new URL[] {

            MetaInfServicesLookupTest.class.getResource("data/services-jar-1.jar"),

            MetaInfServicesLookupTest.class.getResource("data/services-jar-2.jar"),

        });

    }

    public void testBasicUsage() throws Exception {

        Lookup l = new MetaInfServicesLookup(c2);

        Class xface = c1.loadClass("org.foo.Interface");

        List results = new ArrayList(l.lookup(new Lookup.Template(xface)).allInstances());

        assertEquals(2, results.size());

        // Note that they have to be in order:

        assertEquals("org.foo.impl.Implementation1", results.get(0).getClass().getName());

        assertEquals("org.bar.Implementation2", results.get(1).getClass().getName());

        // Make sure it does not gratuitously replace items:

        List results2 = new ArrayList(l.lookup(new Lookup.Template(xface)).allInstances());

        assertEquals(results, results2);

    }

    public void testLoaderSkew() throws Exception {

        Class xface1 = c1.loadClass("org.foo.Interface");

        Lookup l3 = new MetaInfServicesLookup(c3);

        // If we cannot load Interface, there should be no impls of course... quietly!

        assertEquals(Collections.EMPTY_LIST,

            new ArrayList(l3.lookup(new Lookup.Template(xface1)).allInstances()));

        Lookup l4 = new MetaInfServicesLookup(c4);

        // If we can load Interface but it is the wrong one, ignore it.

        assertEquals(Collections.EMPTY_LIST,

            new ArrayList(l4.lookup(new Lookup.Template(xface1)).allInstances()));

        // Make sure l4 is really OK - it can load from its own JARs.

        Class xface4 = c4.loadClass("org.foo.Interface");

        assertEquals(2, l4.lookup(new Lookup.Template(xface4)).allInstances().size());

    }

    public void testStability() throws Exception {

        Lookup l = new MetaInfServicesLookup(c2);

        Class xface = c1.loadClass("org.foo.Interface");

        Object first = l.lookup(new Lookup.Template(xface)).allInstances().iterator().next();

        l = new MetaInfServicesLookup(c2a);

        Object second = l.lookup(new Lookup.Template(xface)).allInstances().iterator().next();

        assertEquals(first, second);

    }

}

*.jar

<?xml version="1.0"?>

<!--

                Sun Public License Notice

The contents of this file are subject to the Sun Public License

Version 1.0 (the "License"). You may not use this file except in

compliance with the License. A copy of the License is available at

http://www.sun.com/

The Original Code is NetBeans. The Initial Developer of the Original

Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun

Microsystems, Inc. All Rights Reserved.

-->

<project name="org.openide.util test data" basedir="." default="all">

    <target name="all">

        <javac srcdir="services-jar-1" destdir="services-jar-1"/>

        <jar jarfile="services-jar-1.jar" basedir="services-jar-1"/>

        <javac srcdir="services-jar-2" destdir="services-jar-2" classpath="services-jar-1.jar"/>

        <jar jarfile="services-jar-2.jar" basedir="services-jar-2"/>

    </target>

    <target name="clean">

        <delete>

            <fileset dir="." includes="**/*.class, *.jar"/>

        </delete>

    </target>

</project>

# Some header info, maybe.

# Our first impl here:

org.foo.impl.Implementation1

package org.foo;

public interface Interface {}

package org.foo.impl;

import org.foo.Interface;

public class Implementation1 implements Interface {}

org.bar.Implementation2

package org.bar;

import org.foo.Interface;

public class Implementation2 implements Interface {}