Attachment #13368 for bug #32142

View | Details | Raw Unified | Return to bug 32142
Collapse All | Expand All

Lines 1393-1398 Link Here

(-)build.xml (+9 lines)
1393	<include name="taskdefs/test2.antlib.xml"/>	1393	<include name="taskdefs/test2.antlib.xml"/>
1394	</zipfileset>	1394	</zipfileset>
1395	</jar>	1395	</jar>
		1396
		1397	<jar jarfile="${build.tests}/org/apache/tools/ant/include.jar">
		1398	<zipfileset dir="${tests.etc.dir}" fullpath="META-INF/services/org.apache.tools.ant.helper.EntityResolver">
		1399	<include name="core/include/entityResolverTest.txt"/>
		1400	</zipfileset>
		1401	<zipfileset dir="${tests.etc.dir}" fullpath="PUBLIC/include.inc">
		1402	<include name="core/include/public/include.inc"/>
		1403	</zipfileset>
		1404	</jar>
1396	</target>	1405	</target>
1397		1406
1398	<target name="dump-info" depends="dump-sys-properties,run-which"/>	1407	<target name="dump-info" depends="dump-sys-properties,run-which"/>




<html>

  <head>
    <meta http-equiv="Content-Language" content="en-us"></meta>
    <title>External Entities</title>
  </head>

  <body>
    <h2><a name="entities">External Entities</a></h2>
    <h3>Description</h3>
    <p>
      The XML parser used by ant is capable of resolving parsed external
      entities using system identifiers and, when configured appropriately,
      public identifiers.  These entities appear in one of the following forms:
    </p>
    <blockquote>
      <pre>
        &lt;!ENTITY <U>Name</U> SYSTEM <U>System Identifier</U>&gt;
        &lt;!ENTITY <U>Name</U> PUBLIC <U>Public Identifier</U> <U>System Identifier</U>&gt;
      </pre>
    </blockquote>
    <h3><a name="system">System Identifier</a></h3>
    <p>
      A URI that uniquely identifies the external resource whose contents will become the entity's definition.  All Java protocols are supported as well as Ant's custom protocol (<A href="../protocol.html#resource">resource</A>).
    </p>
    <h3><a name="public">Public Identifier</a></h3>
    <p>
      A public identifier is an unique, but otherwise, arbitrary identifier.  When using public identifiers, Ant depends upon an entity resolver identified by the JDK service "org.apache.tools.ant.helper.EntityResolver".  The author of this service may provide any implementation for mapping public identifiers to InputSource objects so long as the service's implementation extends the org.apache.tools.ant.helper.EntityResolver class.
    </p>
    <p>
      A sample implementation for a custom entity resolver is:
      <blockquote>
        <pre>
package my.org.ant.helper;

import org.apache.tools.ant.Project;
import org.xml.sax.InputSource;

public class PublicEntityResolver extends org.apache.tools.ant.helper.EntityResolver {
    /**
     * Resolves XML external entities.  Attempts to get the resource
     * using the system ID so that the most up-to-date resource is
     * used.  However, if the system ID fails then uses the public ID
     * to reference a backup copy of the resource.
     *
     * @param publicId The public identifier, or &lt;code&gt;null&lt;/code&gt;
     *                 if none is available. 
     * @param systemId The system identifier provided in the XML
     *                 document. Will not be &lt;code&gt;null&lt;/code&gt;.
     */
    public InputSource resolveEntity(String publicId,
                                     String systemId) {
        InputSource source = super.resolveEntity(publicId, systemId);

        if (source == null && publicId != null) {
            getProject().log("resolving publicId: " + publicId, Project.MSG_VERBOSE);

            // Use the public identifier to identify entities that
            // I stored within the same jar as this resolver.  In
            // principle, this will let me retrieve a resource
            // even when the system ID is blocked.
            if ("-- my public Identifier --".equals(publicId)) {
                String cachedResource="local/resource/my_private_resource_name";

                ClassLoader ldr = this.getClass().getClassLoader();
                source = 
                  new InputSource (ldr.getResource(cachedResource));
                source.setPublic(publicId);
            } else {
                getProject().log("failed to resolve publicId: " + publicId, Project.MSG_WARN);
            }
        }

        return source;
    }
}
          
        </pre>
      </blockquote>
    </p>
    <p>
Installation of this custom resolver requires construction of a jar file containing, as a minimum, two files.  The first file is a provider configuration file that will be placed in the jar file with the resource name 'META&minus;INF/services/org.apache.tools.ant.helper.EntityResolver'.  The content of this file is the fully qualified class name of the class implementing this service (See the JavaDoc for the java.util.jar package for full details).  The second file is the Java class file named by the provider configuration file.
    </p>
    
<hr>
<p align="center">Copyright &copy; 2003-2004 Apache Software
Foundation. All rights Reserved.</p>

</body>
</html>


Lines 14-19 Link Here

(-)docs/manual/conceptstypeslist.html (-1 / +3 lines)
14	<a href="clonevm.html">build.clonevm</a><br>	14	<a href="clonevm.html">build.clonevm</a><br>
15	<a href="sysclasspath.html">build.sysclasspath</a><br>	15	<a href="sysclasspath.html">build.sysclasspath</a><br>
16	<a href="CoreTasks/common.html">Common Attributes</a><br>	16	<a href="CoreTasks/common.html">Common Attributes</a><br>
		17	<a href="protocol.html">resource Protocol</a><br>
17		18
18	<h3>Core Types</h3>	19	<h3>Core Types</h3>
19	<a href="CoreTypes/description.html">Description Type</a><br>	20	<a href="CoreTypes/description.html">Description Type</a><br>
Lines 45-51 Link Here
45	<a href="CoreTypes/antlib.html">Antlib</a><br>	46	<a href="CoreTypes/antlib.html">Antlib</a><br>
46	<a href="CoreTypes/antlib.html#antlibnamespace">Antlib namespace</a><br>	47	<a href="CoreTypes/antlib.html#antlibnamespace">Antlib namespace</a><br>
47	<a href="CoreTypes/antlib.html#currentnamespace">Current namespace</a><br>	48	<a href="CoreTypes/antlib.html#currentnamespace">Current namespace</a><br>
48		49	<h3>Entity Resolution</h3>
		50	<a href="CoreTypes/entities.html">XML Entities</a><br>
49		51
50	<h3>Custom Components</h3>	52	<h3>Custom Components</h3>
51	<a href="CoreTypes/custom-programming.html">Custom Components</a><br>	53	<a href="CoreTypes/custom-programming.html">Custom Components</a><br>




<html>

  <head>
    <meta http-equiv="Content-Language" content="en-us"></meta>
    <title>Ant Uniform Resource Locator (URL) Protocol</title>
  </head>

  <body>
    <h2><a name="resource">Ant Uniform Resource Locator (URL) Protocol</a></h2>
    <h3>Description</h3>
    <p>Ant provides a custom URL protocol (<b>resource</b>) for referencing resources located via Ant's class loaders.  A URL using the <b>resource</b> protocol will use the syntax, <code>resource:path</code>, where <code>path</code> names the resource.  Leading slashes(/) on the <code>path</code> are automatically stripped off to match the class loader convention of using relative paths to name resources.
    </p>
    <p>
      Ant will search for the resource first using the current thread's context class loader.  If that loader fails, Ant will then try the class loader used to load the Ant core class files.  Finally, if the resource still hasn't been located, Ant will search for the resource using the system class loader.
    </p>
    <p>
      This protocol does not support specifying a host (//host name), port (:port number), fragment (#fragment), or query parameters (?parameters).
    </p>
    <p>
      The <b>resource</b> protocol may be used by any part (type, task, etc) of Ant. No type or task may change the class path referenced by the <b>resource</b> protocol except by changing the project's class path.
    </p>
    <p>
      In the event that the same resource is located in multiple jar files or directories, the <b>resource</b> protocol will return the first resource found when searching in the order specified by the project's classpath.
    </p>
<hr>
<p align="center">Copyright &copy; 2003-2004 Apache Software
Foundation. All rights Reserved.</p>

</body>
</html>

Line 0 Link Here

(-)src/etc/testcases/core/include/entityResolverTest.txt (+1 lines)
	1	org.apache.tools.ant.IncludeTest$EntityResolver

Line 0 Link Here

(-)src/etc/testcases/core/include/public/include.inc (+3 lines)
	1	<target name="test1">
	2	<echo message="from included entity"/>
	3	</target>

Line 0 Link Here

(-)src/etc/testcases/core/include/public/include.xml (+9 lines)
	1	<?xml version="1.0"?>
	2
	3	<!DOCTYPE project [
	4	<!ENTITY include PUBLIC "-- include.inc --" "file:unknown">
	5	]>
	6
	7	<project name="include-test" basedir="." default="test1">
	8	&include;
	9	</project>

Line 0 Link Here

(-)src/etc/testcases/core/include/resource/bad-include.xml (+9 lines)
	1	<?xml version="1.0"?>
	2
	3	<!DOCTYPE project [
	4	<!ENTITY include SYSTEM "resource:/core/include/resource/missing.inc">
	5	]>
	6
	7	<project name="include-test" basedir="." default="test1">
	8	&include;
	9	</project>

Line 0 Link Here

(-)src/etc/testcases/core/include/resource/include.inc (+3 lines)
	1	<target name="test1">
	2	<echo message="from included entity"/>
	3	</target>

Line 0 Link Here

(-)src/etc/testcases/core/include/resource/include.xml (+9 lines)
	1	<?xml version="1.0"?>
	2
	3	<!DOCTYPE project [
	4	<!ENTITY include SYSTEM "resource:/core/include/resource/include.inc">
	5	]>
	6
	7	<project name="include-test" basedir="." default="test1">
	8	&include;
	9	</project>




import java.util.Vector;
import org.apache.tools.ant.helper.ProjectHelper2;
import org.apache.tools.ant.util.LoaderUtils;
import org.apache.tools.ant.util.ServiceUtils;
import org.xml.sax.AttributeList;

/**

        // automatically if in CLASSPATH, with the right META-INF/services.
        if (helper == null) {
            try {
                String[] helperClasses = ServiceUtils.newServiceUtils().serviceProvidersFor(ProjectHelper.class);
                if (helperClasses != null) {
                    helperClass = helperClasses [0];
                
                    if (helperClass != null) {
                        helper = newHelper (helperClass);
                    is = ClassLoader.getSystemResourceAsStream(SERVICE_ID);
                }

                if (is != null) {
                    // This code is needed by EBCDIC and other strange systems.
                    // It's a fix for bugs reported in xerces
                    InputStreamReader isr;
                    try {
                        isr = new InputStreamReader(is, "UTF-8");
                    } catch (java.io.UnsupportedEncodingException e) {
                        isr = new InputStreamReader(is);
                    }
                    BufferedReader rd = new BufferedReader(isr);

                    String helperClassName = rd.readLine();
                    rd.close();

                    if (helperClassName != null
                        && !"".equals(helperClassName)) {

                        helper = newHelper(helperClassName);
                    }
                }
            } catch (BuildException e) {
                throw e;
            } catch (Exception e) {
                throw new BuildException (e);
            }
        }





/*
 * Copyright  2000-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.helper;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
import org.apache.tools.ant.util.FileUtils;
import org.apache.tools.ant.util.LoaderUtils;
import org.xml.sax.InputSource;

/**
 * <P>Ant's default entity resolver provides for resolving relative file URLs
 * with respect to the current build file's directory.</P> <P>Developers who
 * wish to provide their own entity resolver must extend from this class.</P>
 */
public class EntityResolver implements org.xml.sax.EntityResolver {
    private File          buildFileParent;
    private AntXMLContext context;
    private Project       project;

    /**
     * Construct an uninitialized entity resolver.  Ant must call either {@link
     * #setContext(AntXMLContext)}, or {@link
     * #setProject(org.apache.tools.ant.Project)} and {@link
     * #setBuildFileParent(java.io.File)} before this resolver can be used.
     */
    public EntityResolver() {
    }

    /**
     * helper for path -> URI and URI -> path conversions.
     */
    private static final FileUtils fu = FileUtils.newFileUtils();

    /**
     * Set the Context for which this EntityResolver is working.
     *
     * @param context the Ant XML context to configure
     */
    void setContext(AntXMLContext context) {
        this.context = context;
    }

    /**
     * <P>Set the Project for which this EntityResolver is working.</P> <P>NOTE:
     * The project set by this method is ignored once {@link
     * #setContext(AntXMLContext)} has been called.</P>
     *
     * @param project the ANT project to configure.
     */
    void setProject(Project project) {
        this.project = project;
    }

    /**
     * <P>Set the build file parent for resolving relative file URLs.</P>
     * <P>NOTE: The build file parent(directory) set by this method is ignored
     * once {@link #setContext(AntXMLContext)} has been called.</P>
     *
     * @param file the project's build directory
     */
    void setBuildFileParent(File buildFileParent) {
        this.buildFileParent = buildFileParent;
    }

    /**
     * Get the Project for which this EntityResolver is working.
     *
     * @return the ANT Project
     */

    public Project getProject() {
        if (context == null) {
            return project;
        }

        return context.getProject();
    }

    /**
     * Get the BuildFileParent for which this EntityResolver is working.
     *
     * @return the ANT BuildFileParent
     */

    public File getBuildFileParent() {
        if (context == null) {
            return buildFileParent;
        }

        return context.getBuildFileParent();
    }

    /**
     * Get the class loader for this context.
     */
    public ClassLoader getClassLoader() {
        return LoaderUtils.getContextClassLoader();
    }

    /**
     * Resolves file URIs relative to the build file.
     *
     * @param publicId The public identifier, or <code>null</code> if none is
     *                 available. Ignored in this implementation.
     * @param systemId The system identifier provided in the XML document. Will
     *                 not be <code>null</code>.
     */
    public InputSource resolveEntity(String publicId,
                                     String systemId) {
        getProject().log("resolving systemId: " + systemId, Project.MSG_VERBOSE);

        if (systemId.startsWith("file:")) {
            String path = fu.fromURI(systemId);

            File file = new File(path);
            if (!file.isAbsolute()) {
                file = fu.resolveFile(getBuildFileParent(), path);
            }
            try {
                getProject().log("resolved systemId: " + systemId 
                                 + " as " + file.getAbsolutePath(),
                                 Project.MSG_DEBUG);

                InputSource inputSource = 
                    new InputSource(new InputStreamReader(new FileInputStream(file)));
                inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
                return inputSource;
            } catch (FileNotFoundException fne) {
                getProject().log(file.getAbsolutePath() + " could not be found",
                                 Project.MSG_WARN);
            }
        }

        // use default if not file or file not found
        return null;
    }
}





import org.apache.tools.ant.util.JAXPUtils;
import org.apache.tools.ant.util.FileUtils;
import org.apache.tools.ant.util.ServiceUtils;

import org.apache.tools.ant.ProjectHelper;
import org.apache.tools.ant.Project;

     */
    private static FileUtils fu = FileUtils.newFileUtils();

    static {
        URLStreamHandlerFactory factory = 
            (URLStreamHandlerFactory) ServiceUtils.newServiceUtils()
            .serviceFor (URLStreamHandlerFactory.class);

        try {
            java.net.URL.setURLStreamHandlerFactory (factory);
        } catch (Error e) {
            // Error will occur if both ProjectHelper2 and ProjectHelperImpl are loaded
        }
    }

    /**
     * Parse an unknown element from a url
     *

        private Stack antHandlers = new Stack();
        private AntHandler currentHandler = null;
        private AntXMLContext context;
        private EntityResolver entityResolver;

        /**
         * Creates a new RootHandler instance.

            currentHandler = rootHandler;
            antHandlers.push(currentHandler);
            this.context = context;

            this.entityResolver =
                (EntityResolver) ServiceUtils.newServiceUtils()
                .serviceFor (org.apache.tools.ant.helper.EntityResolver.class);

            entityResolver.setContext(context);
        }

        /**

         */
        public InputSource resolveEntity(String publicId,
                                         String systemId) {
            return entityResolver.resolveEntity(publicId, systemId);
            context.getProject().log("resolving systemId: "
                + systemId, Project.MSG_VERBOSE);

            if (systemId.startsWith("file:")) {
                String path = fu.fromURI(systemId);

                File file = new File(path);
                if (!file.isAbsolute()) {
                    file = fu.resolveFile(context.getBuildFileParent(), path);
                }
                try {
                    InputSource inputSource =
                            new InputSource(new FileInputStream(file));
                    inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
                    return inputSource;
                } catch (FileNotFoundException fne) {
                    context.getProject().log(file.getAbsolutePath()
                        + " could not be found", Project.MSG_WARN);
                }

            }
            // use default if not file or file not found
            return null;
        }

        /**




import org.apache.tools.ant.TaskContainer;
import org.apache.tools.ant.UnknownElement;
import org.apache.tools.ant.util.FileUtils;
import org.apache.tools.ant.util.ServiceUtils;
import org.apache.tools.ant.util.JAXPUtils;
import org.xml.sax.AttributeList;
import org.xml.sax.DocumentHandler;

     */
    private static FileUtils fu = FileUtils.newFileUtils();

    static {
        URLStreamHandlerFactory factory = 
            (URLStreamHandlerFactory) ServiceUtils.newServiceUtils()
            .serviceFor (URLStreamHandlerFactory.class);

        try {
            java.net.URL.setURLStreamHandlerFactory (factory);
        } catch (Error e) {
            // Error will occur if both ProjectHelper2 and ProjectHelperImpl are loaded
        }
    }

    /**
     * default constructor
     */

            inputSource.setSystemId(uri);
            project.log("parsing buildfile " + buildFile + " with URI = "
                + uri, Project.MSG_VERBOSE);

            EntityResolver entityResolver =
                (EntityResolver) ServiceUtils.newServiceUtils()
                .serviceFor (org.apache.tools.ant.helper.EntityResolver.class);

            entityResolver.setProject(project);
            entityResolver.setBuildFileParent(buildFileParent);

            HandlerBase hb = new RootHandler(this);
            parser.setDocumentHandler(hb);
            parser.setEntityResolver(entityResolver);
            parser.setErrorHandler(hb);
            parser.setDTDHandler(hb);
            parser.parse(inputSource);

                    be.setLocation(location);
                }
                throw be;
            } else if (t == null) {
                t = exc;
            }

            throw new BuildException(exc.getMessage(), t, location);

            Throwable t = exc.getException();
            if (t instanceof BuildException) {
                throw (BuildException) t;
            } else if (t == null) {
                t = exc;
            }
            throw new BuildException(exc.getMessage(), t);
        } catch (FileNotFoundException exc) {


        public RootHandler(ProjectHelperImpl helperImpl) {
            this.helperImpl = helperImpl;
        }

        /**
         * Resolves file: URIs relative to the build file.
         *
         * @param publicId The public identifier, or <code>null</code>
         *                 if none is available. Ignored in this
         *                 implementation.
         * @param systemId The system identifier provided in the XML
         *                 document. Will not be <code>null</code>.
         */
        public InputSource resolveEntity(String publicId,
                                         String systemId) {

            helperImpl.project.log("resolving systemId: " + systemId, Project.MSG_VERBOSE);

            if (systemId.startsWith("file:")) {
                String path = fu.fromURI(systemId);

                File file = new File(path);
                if (!file.isAbsolute()) {
                    file = fu.resolveFile(helperImpl.buildFileParent, path);
                }
                try {
                    InputSource inputSource = new InputSource(new FileInputStream(file));
                    inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
                    return inputSource;
                } catch (FileNotFoundException fne) {
                    helperImpl.project.log(file.getAbsolutePath() + " could not be found",
                                Project.MSG_WARN);
                }
            }
            // use default if not file or file not found
            return null;
        }

        /**




/*
 * Copyright  2000-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.helper;

/**
 * <P>Ant's default URL stream handler factory. This factory adds the following
 * class name pattern
 * <code>org.apache.tools.ant.protocol.<U><I>protocol</I></U>.Handler</code> to
 * the default patterns supported by Java.  Any number of custom protocols may
 * be added to Ant by simply declaring a new handler class matching this
 * pattern.</P>
 *
 * <P>Ant's resource handler, {@link
 * org.apache.tools.ant.protocol.resource.Handler}, may be used as an example
 * implementation.</P>
 * 
 * <P>This handler may be overriden using JDK1.3 service discovery with the
 * service identifier of
 * <code>META&#8211;INF/services/org.apache.tools.ant.helper.URLStreamHandlerFactory</code>.</P>
 */

public class URLStreamHandlerFactory implements java.net.URLStreamHandlerFactory {
    /**
     * Creates a new <code>URLStreamHandler</code> instance with the specified
     * protocol.
     *
     * @param protocol the protocol ("<code>resource</code>", <code>ftp</code>",
     * "<code>http</code>", "<code>nntp</code>", etc.).
     * @return a <code>URLStreamHandler</code> for the specific protocol.
     */
    public java.net.URLStreamHandler createURLStreamHandler(String protocol) {
        try {
            return (java.net.URLStreamHandler)
                this.getClass().getClassLoader()
                .loadClass("org.apache.tools.ant.protocol." + protocol 
                           + ".Handler").newInstance();
        } catch (Exception e) {
            // It's OK for Ant to not provide a handler.  When that happens,
            // java.net.URL will fall back on its internal logic.
        }

        return null;
    }
}




/*
 * Copyright  2000-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.protocol.resource;

import java.io.IOException;
import java.net.URL;

/**
 * The URL stream handler for the resource protocol.  This handler parses the
 * string representation of a URL storing the various elements within a provided
 * URL object. It also provides the factory for creating a connection specific
 * to a URL based on this protocol.
 */
public final class Handler extends java.net.URLStreamHandler {
    /**
     * Default constructor.  Creates a component used by the java.net framework
     * to add support for the <code>resource</code> protocol.
     */
    public Handler () {
    }

    /**
     * Determines whether two URLs reference the same resource.
     */
    protected boolean equals(URL u1, URL u2) {
	String path1 = u1.getPath();
	String path2 = u2.getPath();
	return (super.equals(u1, u2) && 
                path1 == null? path2 == null: path1.equals(path2));
    }

    /**
     * <p>Parses the string representation of a <code>URL</code> into a
     * <code>URL</code> object.</P> <p>If there is any inherited context, then
     * it has already been copied into the <code>URL</code> argument.</P>
     * <p>Uses the <code>parseURL</code> method of <code>URLStreamHandler</code>
     * to parse the string representation as if it were an <code>http</code>
     * specification. Standard components, such as the authority and query, must
     * not be present for the <code>spec</code> to be legal.</P>
     *
     * @param u the <code>URL</code> to receive the result of parsing the spec.
     * @param spec the <code>String</code> representing the URL that must be
     * parsed.
     * @param start the character index at which to begin parsing. This is just
     * past the '<code>:</code>' (if there is one) that specifies the
     * determination of the protocol name.
     * @param limit the character position to stop parsing at. This is the end
     * of the string or the position of the "<code>#</code>" character, if
     * present. All information after the sharp sign indicates an anchor.
     */
    protected void parseURL (URL url, String spec, int start, int finish) {
        super.parseURL (url, spec, start, finish);

        if (url.getAuthority () != null) {
            throw new RuntimeException ("resource: protocol does not support "
                                        + "setting the URL's authority "
                                        + "(i.e. host, port, user, or password)");
        }

        if (url.getQuery () != null) {
            throw new RuntimeException ("resource: protocol does not " 
                                        + "support query parameters.");
        }
    }

    /**
     * Opens a connection to the object referenced by 
     * <code>url</code>.
     *
     * @param url the URL that this connects to.
     * @return an object specific to a <code>resource:URL</code> that extends
     * from the {@link java.net.URLConnection} class.
     * @exception IOException if an I/O error occurs while opening the
     * connection.
     */
    protected java.net.URLConnection openConnection(URL url) throws IOException {
	return new ResourceURLConnection(url);
    }
}




/*
 * Copyright  2000-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.protocol.resource;

import org.apache.tools.ant.util.LoaderUtils;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.util.Collections;

/** open an resource input stream given a URL */

public class ResourceURLConnection extends URLConnection {
    /**
     * URLConnection of the jar URL that is the actual source of this resource.
     */
    protected URLConnection physicalConnection = null;

    /**
     * <P>Construct a URL connection that is specific to the resource protocol.  This constructor
     * decodes the given URL to get the resource name, performs a class loader search to locate
     * that resource, and then constructs the physical URLConnection to that resource.</P>
     * <P>The physical connection is created by first getting the physical URL by calling
     * getResource() on the context class loader (See
     * <code>LoaderUtils.getContextClassLoader()</code>).  If that class loader fails, a second
     * attempt will be made using the same class loader as used to load the ResourceURLConnection
     * class.  Finally, if neither of those class loaders succeed, the system class loader will
     * be attempted.</P>
     *
     * @param url the target of this connection
     * @throws IOException to report that the resource can not be located as well as all I/O
     * errors while creating the physical connection.
     */
    public ResourceURLConnection(URL url) throws IOException {
	super(url);

        String resourceName = url.getPath();
        
        // Decode escaped characters now that the path has been identified.  This will permit
        // escaping path delimiters into the actual path.
        // Note: FileUtils.fromURI() can NOT be used here as it is hardcoded to only work with
        // file: URLs.
        resourceName = URLDecoder.decode(resourceName);

        URL physicalUrl = null;
        findURL:
        {
            ClassLoader[] loaders = new ClassLoader[] {
                LoaderUtils.getContextClassLoader(),
                this.getClass().getClassLoader()};

            for (int i = 0; i < loaders.length; i++) {
                physicalUrl = loaders[i].getResource(resourceName);
                if (physicalUrl != null) {
                    break findURL;
                }
            }

            for (int i = 0; i < loaders.length; i++) {
                physicalUrl = loaders[i].getSystemResource(resourceName);
                if (physicalUrl != null) {
                    break findURL;
                }
            }

            StringBuffer msg = new StringBuffer();
            msg
                .append("Failed to find resource ")
                .append(url)
                .append(" in ");

            for (int i = 0; i < loaders.length; i++) {
                if (loaders[i] instanceof org.apache.tools.ant.AntClassLoader) {
                    msg.append(((org.apache.tools.ant.AntClassLoader) loaders[i]).getClasspath());
                } else if (loaders[i] instanceof java.net.URLClassLoader) {
                    URL urls[] = ((java.net.URLClassLoader) loaders[i]).getURLs();

                    msg.append(urls[0].toString());
                    for (int j = 1; j < urls.length; j++) {
                        msg.append(", ");
                        msg.append(urls[j].toString());
                    }
                }
            }

            throw new IOException(msg.toString());
        }

        physicalConnection = physicalUrl.openConnection();
    }

    /**
     * Opens a communications link to the resource referenced by the physical connection.
     */
    public void connect() throws IOException {
	physicalConnection.connect();
    }

    /**
     * Returns the value of the <code>allowUserInteraction</code> field for
     * this object.
     *
     * @return  the value of the <code>allowUserInteraction</code> field for
     *          this object.
     * @see     #setAllowUserInteraction(boolean)
     */
    public boolean getAllowUserInteraction() {
        return physicalConnection.getAllowUserInteraction();
    }

    /**
     * Returns the default value of a <code>URLConnection</code>'s
     * <code>useCaches</code> flag.
     * <p>
     * Ths default is "sticky", being a part of the static state of all
     * URLConnections.  This flag applies to the next, and all following
     * URLConnections that are created.
     *
     * @return  the default value of a <code>URLConnection</code>'s
     *          <code>useCaches</code> flag.
     * @see     #setDefaultUseCaches(boolean)
     */
    public boolean getDefaultUseCaches() {
        return physicalConnection.getDefaultUseCaches();
    }

    /**
     * Returns the value of this <code>URLConnection</code>'s
     * <code>doInput</code> flag.
     *
     * @return  the value of this <code>URLConnection</code>'s
     *          <code>doInput</code> flag.
     * @see     #setDoInput(boolean)
     */
    public boolean getDoInput() {
        return physicalConnection.getDoInput();
    }

    /**
     * Returns the value of this <code>URLConnection</code>'s
     * <code>doOutput</code> flag.
     *
     * @return  the value of this <code>URLConnection</code>'s
     *          <code>doOutput</code> flag.
     * @see     #setDoOutput(boolean)
     */
    public boolean getDoOutput() {
        return physicalConnection.getDoOutput();
    }

    /**
     * Returns the value of this <code>URLConnection</code>'s
     * <code>useCaches</code> field.
     *
     * @return  the value of this <code>URLConnection</code>'s
     *          <code>useCaches</code> field.
     * @see #setUseCaches(boolean)
     */
    public boolean getUseCaches() {
        return physicalConnection.getUseCaches();
    }

    /**
     * Returns the value of the <code>content-length</code> header field.
     *
     * @return  the content length of the resource that this connection's URL
     *          references, or <code>-1</code> if the content length is
     *          not known.
     */
    public int getContentLength() {
        return physicalConnection.getContentLength();
    }

    /**
     * Returns the value of the named field parsed as a number.
     * <p>
     * This form of <code>getHeaderField</code> exists because some
     * connection types (e.g., <code>http-ng</code>) have pre-parsed
     * headers. Classes for that connection type can override this method
     * and short-circuit the parsing.
     *
     * @param   name      the name of the header field.
     * @param   Default   the default value.
     * @return  the value of the named field, parsed as an integer. The
     *          <code>Default</code> value is returned if the field is
     *          missing or malformed.
     */
    public int getHeaderFieldInt(String name,int Default) {
        return physicalConnection.getHeaderFieldInt(name, Default);
    }

    /**
     * Returns an input stream that reads from this open connection.
     *
     * @return     an input stream that reads from this open connection.
     * @exception  IOException              if an I/O error occurs while
     *               creating the input stream.
     * @exception  UnknownServiceException  if the protocol does not support
     *               input.
     */
    public java.io.InputStream getInputStream()throws IOException {
        return physicalConnection.getInputStream();
    }

    /**
     * Returns an output stream that writes to this connection.
     *
     * @return     an output stream that writes to this connection.
     * @exception  IOException              if an I/O error occurs while
     *               creating the output stream.
     * @exception  UnknownServiceException  if the protocol does not support
     *               output.
     */
    public java.io.OutputStream getOutputStream()throws IOException {
        return physicalConnection.getOutputStream();
    }

    /**
     * Retrieves the contents of this URL connection.
     *
     * @return     the object fetched. The <code>instanceof</code> operator
     *               should be used to determine the specific kind of object
     *               returned.
     * @exception  IOException              if an I/O error occurs while
     *               getting the content.
     * @exception  UnknownServiceException  if the protocol does not support
     *               the content type.
     * @see        java.net.URLConnection#getContent()
     */
    public Object getContent()throws IOException {
        return physicalConnection.getContent();
    }

    /**
     * Retrieves the contents of this URL connection.
     *
     * @param classes the <code>Class</code> array
     * indicating the requested types
     * @return the object fetched that is the first match of the type specified in the classes
     *         array. Returns <code>null</code> if none of the requested types are supported.
     *         The <code>instanceof</code> operator should be used to determine the specific
     *         kind of object returned.
     * @exception IOException if an I/O error occurs while getting the content.
     * @exception UnknownServiceException if the protocol does not support the content type.
     * @see        java.net.URLConnection#getContent(Class[])
     */
    public Object getContent(Class[] classes) throws IOException {
        return physicalConnection.getContent(classes);
    }

    /**
     * Returns the value of the <code>content-encoding</code> header field.
     *
     * @return  the content encoding of the resource that the URL references,
     *          or <code>null</code> if not known.
     * @see     java.net.URLConnection#getHeaderField(java.lang.String)
     */
    public String getContentEncoding() {
        return physicalConnection.getContentEncoding();
    }

    /**
     * Returns the value of the <code>content-type</code> header field.
     *
     * @return  the content type of the resource that the URL references,
     *          or <code>null</code> if not known.
     * @see     java.net.URLConnection#getHeaderField(java.lang.String)
     */
    public String getContentType() {
        return physicalConnection.getContentType();
    }

    /**
     * <P>Returns the value for the <code>n</code><sup>th</sup> header field.
     * It returns <code>null</code> if there are fewer than
     * <code>n+1</code> fields.</P>
     *
     * <P>This method can be used in conjunction with the
     * {@link #getHeaderFieldKey(int) getHeaderFieldKey} method to iterate through all
     * the headers in the message. </P>
     *
     * @param   n   an index, where n>=0
     * @return  the value of the <code>n</code><sup>th</sup> header field
     *		or <code>null</code> if there are fewer than <code>n+1</code> fields
     * @see     java.net.URLConnection#getHeaderFieldKey(int)
     */
    public String getHeaderField(int n) {
        return physicalConnection.getHeaderField(n);
    }

    /**
     * <P>Returns the value of the named header field.</P>
     *
     * <P>If called on a connection that sets the same header multiple times
     * with possibly different values, only the last value is returned.</P>
     *
     * @param   name   the name of a header field.
     * @return  the value of the named header field, or <code>null</code>
     *          if there is no such field in the header.
     */
    public String getHeaderField(String name) {
        return physicalConnection.getHeaderField(name);
    }

    /**
     * Returns the key for the <code>n</code><sup>th</sup> header field.
     * It returns <code>null</code> if there are fewer than <code>n+1</code> fields.
     *
     * @param   n   an index, where n>=0
     * @return  the key for the <code>n</code><sup>th</sup> header field,
     *          or <code>null</code> if there are fewer than <code>n+1</code>
     *		fields.
     */
    public String getHeaderFieldKey(int n) {
        return physicalConnection.getHeaderFieldKey(n);
    }

    /**
     * Returns the value of the named general request property for this
     * connection.
     *
     * @param key the keyword by which the request is known (e.g., "accept").
     * @return  the value of the named general request property for this
     *           connection. If key is null, then null is returned.
     * @throws IllegalStateException if already connected
     * @see #setRequestProperty(java.lang.String, java.lang.String)
     */
    public String getRequestProperty(String key) {
        return physicalConnection.getRequestProperty(key);
    }

    /**
     * Returns a <code>String</code> representation of this URL connection.
     *
     * @return  a string representation of this <code>URLConnection</code>.
     */
    public String toString() {
	return this.getClass().getName() + ":" + url;
    }

    /**
     * Returns a permission object representing the permission
     * necessary to make the connection represented by this
     * object. This method returns null if no permission is
     * required to make the connection.
     *
     * <p>The permission returned may dependent upon the state of the
     * connection. For example, the permission before connecting may be
     * different from that after connecting. For example, an HTTP
     * sever, say foo.com, may redirect the connection to a different
     * host, say bar.com. Before connecting the permission returned by
     * the connection will represent the permission needed to connect
     * to foo.com, while the permission returned after connecting will
     * be to bar.com.
     *
     * <p>Permissions are generally used for two purposes: to protect
     * caches of objects obtained through URLConnections, and to check
     * the right of a recipient to learn about a particular URL. In
     * the first case, the permission should be obtained
     * <em>after</em> the object has been obtained. For example, in an
     * HTTP connection, this will represent the permission to connect
     * to the host from which the data was ultimately fetched. In the
     * second case, the permission should be obtained and tested
     * <em>before</em> connecting.
     *
     * @return the permission object representing the permission
     * necessary to make the connection represented by this
     * URLConnection.
     *
     * @exception IOException if the computation of the permission
     * requires network or file I/O and an exception occurs while
     * computing it.
     */
    public java.security.Permission getPermission()throws IOException {
        return physicalConnection.getPermission();
    }

    /**
     * Returns the value of the <code>date</code> header field.
     *
     * @return  the sending date of the resource that the URL references,
     *          or <code>0</code> if not known. The value returned is the
     *          number of milliseconds since January 1, 1970 GMT.
     * @see     java.net.URLConnection#getHeaderField(java.lang.String)
     */
    public long getDate() {
        return physicalConnection.getDate();
    }

    /**
     * Returns the value of the <code>expires</code> header field.
     *
     * @return  the expiration date of the resource that this URL references,
     *          or 0 if not known. The value is the number of milliseconds since
     *          January 1, 1970 GMT.
     * @see     java.net.URLConnection#getHeaderField(java.lang.String)
     */
    public long getExpiration() {
        return physicalConnection.getExpiration();
    }

    /**
     * Returns the value of the named field parsed as date.
     * The result is the number of milliseconds since January 1, 1970 GMT
     * represented by the named field.
     * <p>
     * This form of <code>getHeaderField</code> exists because some
     * connection types (e.g., <code>http-ng</code>) have pre-parsed
     * headers. Classes for that connection type can override this method
     * and short-circuit the parsing.
     *
     * @param   name     the name of the header field.
     * @param   Default   a default value.
     * @return  the value of the field, parsed as a date. The value of the
     *          <code>Default</code> argument is returned if the field is
     *          missing or malformed.
     */
    public long getHeaderFieldDate(String name,long Default) {
        return physicalConnection.getHeaderFieldDate(name, Default);
    }

    /**
     * Returns the value of this object's <code>ifModifiedSince</code> field.
     *
     * @return  the value of this object's <code>ifModifiedSince</code> field.
     * @see #setIfModifiedSince(long)
     */
    public long getIfModifiedSince() {
        return physicalConnection.getIfModifiedSince();
    }

    /**
     * Returns the value of the <code>last-modified</code> header field.
     * The result is the number of milliseconds since January 1, 1970 GMT.
     *
     * @return  the date the resource referenced by this
     *          <code>URLConnection</code> was last modified, or 0 if not known.
     * @see     java.net.URLConnection#getHeaderField(java.lang.String)
     */
    public long getLastModified() {
        return physicalConnection.getLastModified();
    }

    /**
     * Set the value of the <code>allowUserInteraction</code> field of
     * this <code>URLConnection</code>.
     *
     * @param   allowuserinteraction   the new value.
     * @throws IllegalStateException if already connected
     * @see     #getAllowUserInteraction()
     */
    public void setAllowUserInteraction(boolean allowuserinteraction) {
        physicalConnection.setAllowUserInteraction(allowuserinteraction);
    }

    /**
     * Sets the default value of the <code>useCaches</code> field to the
     * specified value.
     *
     * @param   defaultusecaches   the new value.
     * @see     #getDefaultUseCaches()
     */
    public void setDefaultUseCaches(boolean defaultusecaches) {
        physicalConnection.setDefaultUseCaches(defaultusecaches);
    }

    /**
     * Sets the value of the <code>doInput</code> field for this
     * <code>URLConnection</code> to the specified value.
     * <p>
     * A URL connection can be used for input and/or output.  Set the DoInput
     * flag to true if you intend to use the URL connection for input,
     * false if not.  The default is true.
     *
     * @param   doinput   the new value.
     * @throws IllegalStateException if already connected
     * @see     java.net.URLConnection#doInput
     * @see #getDoInput()
     */
    public void setDoInput(boolean doinput) {
        physicalConnection.setDoInput(doinput);
    }

    /**
     * Sets the value of the <code>doOutput</code> field for this
     * <code>URLConnection</code> to the specified value.
     * <p>
     * A URL connection can be used for input and/or output.  Set the DoOutput
     * flag to true if you intend to use the URL connection for output,
     * false if not.  The default is false.
     *
     * @param   dooutput   the new value.
     * @throws IllegalStateException if already connected
     * @see #getDoOutput()
     */
    public void setDoOutput(boolean dooutput) {
        physicalConnection.setDoOutput(dooutput);
    }

    /**
     * Sets the value of the <code>ifModifiedSince</code> field of
     * this <code>URLConnection</code> to the specified value.
     *
     * @param   ifmodifiedsince   the new value.
     * @throws IllegalStateException if already connected
     * @see     #getIfModifiedSince()
     */
    public void setIfModifiedSince(long ifmodifiedsince) {
        physicalConnection.setIfModifiedSince(ifmodifiedsince);
    }

    /**
     * Sets the general request property. If a property with the key already
     * exists, overwrite its value with the new value.
     *
     * @param   key     the keyword by which the request is known
     *                  (e.g., "<code>accept</code>").
     * @param   value   the value associated with it.
     * @throws IllegalStateException if already connected
     * @throws NullPointerException if key is <CODE>null</CODE>
     * @see #getRequestProperty(java.lang.String)
     */
    public void setRequestProperty(String key, String value) {
        physicalConnection.setRequestProperty(key, value);
    }

    /**
     * Sets the value of the <code>useCaches</code> field of this
     * <code>URLConnection</code> to the specified value.
     * <p>
     * Some protocols do caching of documents.  Occasionally, it is important
     * to be able to "tunnel through" and ignore the caches (e.g., the
     * "reload" button in a browser).  If the UseCaches flag on a connection
     * is true, the connection is allowed to use whatever caches it can.
     *  If false, caches are to be ignored.
     *  The default value comes from DefaultUseCaches, which defaults to
     * true.
     *
     * @param usecaches a <code>boolean</code> indicating whether
     * or not to allow caching
     * @throws IllegalStateException if already connected
     * @see #getUseCaches()
     */
    public void setUseCaches(boolean usecaches) {
        physicalConnection.setUseCaches(usecaches);
    }

    /**
     * Returns an unmodifiable Map of the header fields.
     * The Map keys are Strings that represent the
     * response-header field names. Each Map value is an
     * unmodifiable List of Strings that represents
     * the corresponding field values.
     *
     * @return a Map of header fields
     * @since 1.4 (returns Collections.EMPTY_MAP for all previous versions)
     */
    public java.util.Map getHeaderFields() {
        try {
            java.lang.reflect.Method method =
                physicalConnection.getClass().getDeclaredMethod("getHeaderFields", new Class[]{});
            return (java.util.Map) method.invoke(physicalConnection, new Object[]{});
        } catch (NoSuchMethodException e) {
        } catch (java.lang.reflect.InvocationTargetException e) {
            Throwable tgt = e.getTargetException();

            if (tgt instanceof IllegalStateException) {
                throw (IllegalStateException) tgt;
            }

            throw new RuntimeException(tgt.getClass().getName() + ": " + tgt.getMessage());
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e.getClass().getName() + ": " + e.getMessage());
        }

        return Collections.EMPTY_MAP;
    }

    /**
     * Returns an unmodifiable Map of general request
     * properties for this connection. The Map keys
     * are Strings that represent the request-header
     * field names. Each Map value is a unmodifiable List
     * of Strings that represents the corresponding
     * field values.
     *
     * @return  a Map of the general request properties for this connection.
     * @throws IllegalStateException if already connected
     * @since 1.4 (returns Collections.EMPTY_MAP for all previous versions)
     */
    public java.util.Map getRequestProperties() {
        try {
            java.lang.reflect.Method method =
                physicalConnection.getClass().getDeclaredMethod("getRequestProperties", new Class[]{});
            return (java.util.Map) method.invoke(physicalConnection, new Object[]{});
        } catch (NoSuchMethodException e) {
        } catch (java.lang.reflect.InvocationTargetException e) {
            Throwable tgt = e.getTargetException();

            if (tgt instanceof IllegalStateException) {
                throw (IllegalStateException) tgt;
            }

            throw new RuntimeException(tgt.getClass().getName() + ": " + tgt.getMessage());
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e.getClass().getName() + ": " + e.getMessage());
        }

	return Collections.EMPTY_MAP;
    }

    /**
     * Adds a general request property specified by a
     * key-value pair.  This method will not overwrite
     * existing values associated with the same key.
     *
     * @param   key     the keyword by which the request is known
     *                  (e.g., "<code>accept</code>").
     * @param   value  the value associated with it.
     * @throws IllegalStateException if already connected
     * @throws NullPointerException if key is null
     * @see #getRequestProperties(java.lang.String)
     * @since 1.4 (does nothing for all previous versions)
     */

    public void addRequestProperty(String s1, String s2) {
        try {
            java.lang.reflect.Method method =
                physicalConnection.getClass()
                .getDeclaredMethod("addRequestProperty",
                                   new Class[]{String.class, String.class});
            method.invoke(physicalConnection, new Object[]{s1, s2});
        } catch (NoSuchMethodException e) {
        } catch (java.lang.reflect.InvocationTargetException e) {
            Throwable tgt = e.getTargetException();

            if (tgt instanceof IllegalStateException) {
                throw (IllegalStateException) tgt;
            }

            throw new RuntimeException(tgt.getClass().getName()
                                       + ": " + tgt.getMessage());
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e.getClass().getName() + ": " + e.getMessage());
        }
    }
}




/*
 * Copyright  2001-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Modifier;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.util.LoaderUtils;

/**
 * A collection of methods that implement the JDK 1.3 service discovery
 * mechanism.  While this API was introduced in JDK 1.3, it's implementation is
 * fully compatible with JDK 1.2.
 */

public class ServiceUtils {
    private static Map knownServiceProviderClassNames = new HashMap ();

    /**
     * Factory for constructing a new ServiceUtils instance.
     *
     * @return a new instance of ServiceUtils.
     */
    public static ServiceUtils newServiceUtils() {
        return new ServiceUtils();
    }

    /**
     * The default constructor.
     */
    protected ServiceUtils() {
    }

    /**
     * Gets the service providers for the specified service.  The service's
     * fully qualified class name is used to construct the name of a service
     * configuration file that should be found using either the context or
     * system class loader.  This configuration file should contain one, or
     * more, class names identifying providers of the specified service.
     *
     * This method simply locates and parses the configuration file without any
     * consideration for the validity of the class names found therein.
     *
     * @param service the interface or class that the service provider must
     * implement
     * @return An array of service provider class names that are presumed to
     * implement the service; null when no providers were found.
     *
     * @since Ant1.6
     * @exception BuildException if the provider class can not be loaded
     */
    public String[] serviceProvidersFor(Class service) throws BuildException {
        String serviceID = "META-INF/services/" + service.getName ();
        String[] classNames = (String[]) knownServiceProviderClassNames.get(serviceID);

        if (classNames == null) {
            try {
                ClassLoader classLoader = LoaderUtils.getContextClassLoader();
                InputStream is = null;
                if (classLoader != null) {
                    is = classLoader.getResourceAsStream(serviceID);
                }
                if (is == null) {
                    is = ClassLoader.getSystemResourceAsStream(serviceID);
                }

                if (is != null) {
                    // This code is needed by EBCDIC and other strange systems.
                    // It's a fix for bugs reported in xerces
                    InputStreamReader isr;
                    try {
                        isr = new InputStreamReader(is, "UTF-8");
                    } catch (java.io.UnsupportedEncodingException e) {
                        isr = new InputStreamReader(is);
                    }
                    BufferedReader rd = new BufferedReader(isr);

                    // This simple parser implements the Service Provider syntax
                    // described in the JAR Specification.
                    String className       = null;
                    List   providerClasses = new Vector ();
                    while ((className = rd.readLine()) != null) {
                        // Strip off comment beginning with first pound sign (#).
                        int pound = className.indexOf ('#');

                        if (pound > -1) {
                            className = className.substring (0, pound);
                        }

                        // Ignore spaces and tabs
                        className = className.trim ();

                        if (!"".equals (className)) {
                            providerClasses.add (className);
                        }
                    }
                    rd.close();

                    if (providerClasses.size () > 0) {
                        classNames = new String [providerClasses.size ()];
                        providerClasses.toArray (classNames);
                        knownServiceProviderClassNames.put(serviceID, classNames);
                    }
                }
            } catch (Exception ex) {
                throw new BuildException("Unable to find service for \""
                                         + serviceID + "\"", ex);
            }
        }

        return classNames;
    }

    /**
     * A constraint based selector to pick one of possibly several service
     * provider classes.  This class represents an extension to the JDK 1.3
     * service discovery mechanism.
     */
    public interface Constraints {
        /**
         * Determines whether the specified service provider class satisfies all
         * of the constraints imposed by the current request.
         *
         * @throws Exception thrown when the provider does not satisfy all of
         * the constraints.
         */
        public void satisfiedBy (Class provider) throws Exception;
    }

    /**
     * Gets the service provider class that provides the specified service.
     * This service provider class must meet all of the following requirements.
     *  <OL><LI>It must have been named in the service provider configuration
     *  file.</LI>
     *  <LI>It must be assignable to the service class (that is, it either
     *  implements or extends the service class).</LI>
     *  <LI>It must provide a public default constructor.</LI>
     *  <LI>It must satisfy the optional constraints parameter.</LI></OL>
     *
     * When no service provider can be found satisfying the preceeding
     * requirements.  A check will be made to see if the service class is itself
     * instantiable as the service provider.  For this to be true, the following
     * requirements must be met.
     *  <OL><LI>It must not be an interface or abstract class.</LI>
     *  <LI>It must provide a public default constructor.</LI>
     *  <LI>It must satisfy the optional constraints parameter.</LI></OL>
     *
     * @param service the interface or class that the service provider must
     * implement
     * @param constraints optional constraints that can be used to select one of
     * several possible service provider classes.  The first class, in order in
     * which they were listed in the service provider configuration file, to
     * satisfy all of the constraints will be returned.
     * @return The class providing the service subject to the constraints; null
     * when no providers were found.
     *
     * @since Ant1.6
     * @exception BuildException if no provider classes were found that
     * satisfied all of the constraints
     */
    public Class serviceProviderFor(Class service,
                                    Constraints constraints) throws BuildException {
        String[] classNames = serviceProvidersFor(service);

        // Use lazy construction to avoid creating a StringBuffer when the first
        // provider satisfies all of the constraints.
        StringBuffer status = null;

        if (classNames != null) {
            ClassLoader classLoader = LoaderUtils.getContextClassLoader();

            for (int i = 0; i < classNames.length; i++) {
                String className = classNames [i];
                Class  provider  = null;

                // Try to load the provider.  If not loaded, continue with next provider.
                try {
                    provider = classLoader.loadClass(className);
                } catch (Exception e) {
                    try {
                        provider = Class.forName(className);
                    } catch (Exception ex) {
                        status = addStatusMsg(status, service,
                                              "  Unable to find class named '"
                                              + className + "'.");
                        continue;
                    }
                }

                String errMsg = validateProvider (provider, service, constraints);

                if (errMsg == null) {
                    return provider;
                }

                status = addStatusMsg(status, service, errMsg);
            }
        }

        // if no valid service providers found in the configuration file, throw
        // the error
        if (status != null) {
            throw new BuildException(status.toString ());
        }

        // No service providers found in the configuration file.  See if it is
        // possible to use the service class as a minimal provider
        String errMsg = validateProvider (service, service, constraints);

        if (errMsg == null) {
            return service;
        }

        return null;
    }

    /**
     * Gets the service provider class that provides the specified service.
     * This service provider class must meet all of the following requirements.
     *  <OL><LI>It must have been named in the service provider configuration
     *  file.</LI>
     *  <LI>It must be assignable to the service class (that is, it either
     *  implements or extends the service class).</LI>
     *  <LI>It must provide a public default constructor.</LI></OL>
     *
     * @param service the interface or class that the service provider must
     * implement
     * @return The class providing the service; null when no service provider
     * was found.
     *
     * @since Ant1.6
     * @exception BuildException if the provider class can not be loaded
     */
    public Class serviceProviderFor(Class service) throws BuildException {
        return serviceProviderFor(service, null);
    }

    /**
     * Gets the service provider instance for the specified service.
     *
     * @param service the interface or class that the service provider must
     * implement
     * @param constraints optional constraints that can be used to select one of
     * several possible service provider classes.  The first class, in order in
     * which they were listed in the service provider configuration file, to
     * satisfy all of the constraints will be returned.
     * @return The instance providing the service
     *
     * @since Ant1.6
     * @exception BuildException if the instance can not created
     */
    public Object serviceFor(Class service,
                             Constraints constraints) throws BuildException {
        try {
            return serviceProviderFor(service, constraints).newInstance ();
        } catch (BuildException e) {
            throw e;
        } catch (Exception e) {
            throw new BuildException("The service provider for "
                                     + service.getClass ()
                                     + " could not be instantiated.");
        }
    }

    /**
     * Gets the service provider instance for the specified service.
     *
     * @param service the interface or class that the service provider must
     * implement
     * @return The instance providing the service
     *
     * @since Ant1.6
     * @exception BuildException if the instance can not created
     */
    public Object serviceFor(Class service) throws BuildException {
        return serviceFor(service, null);
    }

    /**
     * Used internally by serviceProviderFor.  Assembles a multi-line exception
     * message over the course of several calls.
     */
    private StringBuffer addStatusMsg (StringBuffer allMessages,
                                       Class service, String message) {
        if (message != null) {
            if (allMessages == null) {
                allMessages = new StringBuffer ();
                allMessages.append ("Attempting to locate service provider for ");
                allMessages.append (service.getName ());
                allMessages.append ("\n");
            }

            allMessages.append ("  ");
            allMessages.append (message);
            allMessages.append ("\n");
        }

        return allMessages;
    }

    /**
     * Validate the indicated provider by checking that it satisfies all
     * internal and external provider constraints.  If anything is wrong, return
     * a string suitable for throwing in an exception.
     *
     * @param provider the class that is being validated as the service provider
     * @param service the interface or class that the service provider must
     * implement
     * @param constraints optional constraints that can be used to select one of
     * several possible service provider classes.  The first class, in order in
     * which they were listed in the service provider configuration file, to
     * satisfy all of the constraints will be returned.
     * @return a string suitable for use as the message in an exception
     *
     * @since Ant1.6
     */
    private String validateProvider(Class provider, Class service, Constraints constraints) {
        // Validate the provider class
        if (provider.isInterface ()){
            return provider.getName() + " can not be a provider as it is an interface.";
        } else if (Modifier.isAbstract(provider.getModifiers())) {
            return provider.getName() + " can not be a provider as it is abstract.";
        } else if (provider.isArray()) {
            return provider.getName() + " can not be a provider as it is an array.";
        } else if (provider.isPrimitive()) {
            return provider.getName() + " can not be a provider as it is primitive.";
        } else if (service.isAssignableFrom(provider) == false) {
            return provider.getName() + " can not be cast to " + service.getName ();
        }

        // Validate the provider's constructor

        // Use getDeclaredConstructors, not getConstructor nor getConstructors,
        // to get constructor when class is using implicit default constructor.
        foundPublicDefaultConstructor: {
            Constructor[] constructors = provider.getDeclaredConstructors();

            for (int i = 0; i < constructors.length; i++) {
                Constructor c = constructors [i];
                if (Modifier.isPublic (c.getModifiers ()) 
                    && c.getParameterTypes ().length == 0) {
                    break foundPublicDefaultConstructor;
                }
            }

            return "No default constructor for " + provider.getName();
        }

        // This provider satisfies the built-in constraints.

        // if the caller provided custom constraints, check them.
        if (constraints != null) {
            try {
                constraints.satisfiedBy(provider);
            } catch (Exception e) {
                return e.getMessage ();
            }
        }

        return null; // valid provider
    }
}

Lines 18-23 Link Here

(-)src/testcases/org/apache/tools/ant/IncludeTest.java (+49 lines)
18	package org.apache.tools.ant;	18	package org.apache.tools.ant;
19		19
20	import org.apache.tools.ant.BuildFileTest;	20	import org.apache.tools.ant.BuildFileTest;
		21	import org.apache.tools.ant.util.LoaderUtils;
		22	import java.net.URL;
		23	import java.net.URLClassLoader;
		24	import org.xml.sax.InputSource;
		25	import java.io.InputStream;
		26	import java.io.InputStreamReader;
21		27
22	/**	28	/**
23	* Test the build file inclusion using XML entities.	29	* Test the build file inclusion using XML entities.
Lines 122-125 Link Here
122	expectLog("test1", "from included entity in 'with space'");	128	expectLog("test1", "from included entity in 'with space'");
123	}	129	}
124		130
		131	public void testOfResource() {
		132	configureProject("src/etc/testcases/core/include/resource/include.xml");
		133	expectLog("test1", "from included entity");
		134	}
		135
		136	public void testOfBadResource() {
		137	try {
		138	configureProject("src/etc/testcases/core/include/resource/bad-include.xml");
		139	} catch (BuildException e) {
		140	assertTrue(e.getMessage() + " should contain 'Failed to find resource resource:'",
		141	e.getMessage().indexOf("Failed to find resource resource:") > -1);
		142	}
		143	}
		144
		145	public void testOfPublicId() {
		146	URL jarURL = this.getClass().getResource("/org/apache/tools/ant/include.jar");
		147	assertNotNull(jarURL);
		148
		149	ClassLoader parentLoader = LoaderUtils.getContextClassLoader();
		150	URLClassLoader testLoader = new URLClassLoader(new URL[]{jarURL},
		151	parentLoader);
		152	LoaderUtils.setContextClassLoader(testLoader);
		153	configureProject("src/etc/testcases/core/include/public/include.xml");
		154	expectLog("test1", "from included entity");
		155	LoaderUtils.setContextClassLoader(parentLoader);
		156	}
		157
		158	public static class EntityResolver extends org.apache.tools.ant.helper.EntityResolver {
		159	public InputSource resolveEntity(String publicId,
		160	String systemId) {
		161	if ("-- include.inc --".equals(publicId)) {
		162	InputStream is = getClassLoader().getResourceAsStream("PUBLIC/include.inc");
		163
		164	if (is != null) {
		165	InputSource inputSource = new InputSource(new InputStreamReader(is));
		166	inputSource.setPublicId(publicId);
		167	return inputSource;
		168	}
		169	}
		170
		171	return super.resolveEntity(publicId, systemId);
		172	}
		173	}
125	}	174	}




/*
 * Copyright  2001-2004 The Apache Software Foundation
 *
 *  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.apache.tools.ant.util;

import java.io.*;
import java.util.jar.*;

import junit.framework.TestCase;

import org.apache.tools.ant.util.LoaderUtils;
import org.apache.tools.ant.BuildException;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

/**
 * Tests for org.apache.tools.ant.util.ServiceUtils.
 *
 */
public class ServiceUtilsTest extends TestCase {

    private ServiceUtils su;

    public ServiceUtilsTest(String name) {
        super(name);
    }

    interface ServiceNoProvider {};

    abstract static class AbstractService {} {
    }

    interface ServiceNoConfig {};

    private byte[] getJarContents () {
        ByteArrayOutputStream baos = new ByteArrayOutputStream ();

        try {
            JarOutputStream jos = new JarOutputStream (baos);
            PrintStream     ps  = new PrintStream (jos, true);

            jos.putNextEntry (new JarEntry ("META-INF/services/" + ServiceNoProvider.class.getName ()));
            ps.println ("# comment"); // legal comment
            ps.println ("  # comment"); // ignorable whitespace with comment
            ps.println (ServiceNoProvider.class.getName () + "# comment"); // Interface, not instantiable
            ps.println (""); // blank line

            jos.putNextEntry (new JarEntry ("META-INF/services/" + NoDefaultConstructorProvider.class.getName ()));
            ps.println (NoDefaultConstructorProvider.class.getName ());

            jos.putNextEntry (new JarEntry ("META-INF/services/" + PrivateDefaultConstructorProvider.class.getName ()));
            ps.println (PrivateDefaultConstructorProvider.class.getName ());

            jos.putNextEntry (new JarEntry ("META-INF/services/" + AbstractService.class.getName ()));
            ps.println (NoDefaultConstructorProvider.class.getName ()); // not valid (wrong provider)
            ps.println (AbstractService   .class.getName ()); // not valid (abstract)
            ps.println (ValidProvider     .class.getName ()); // valid
            ps.println (ValidProvider2    .class.getName ()); // also valid
            ps.close ();
            jos.close ();
            baos.close ();
        } catch (IOException e) {
            e.printStackTrace ();
        }

        return baos.toByteArray ();
    }

    public void setUp() {
        su = ServiceUtils.newServiceUtils();

        final byte[] jarByteArray = getJarContents ();

        // This ClassLoader provides a custom getResourcesAsStream method that can retrieve the
        // service configuration files from the custom jar file byte array.  It does not support
        // loading classes from that source.  It depends upon its parent to load classes.
        ClassLoader customLoader = new ClassLoader (LoaderUtils.getContextClassLoader ()) {
                public InputStream getResourceAsStream(String name) {
                    InputStream is = super.getResourceAsStream(name);
                    
                    if (is != null) {
                        return is;
                    }
                    
                    if (name.startsWith ("META-INF/services/") == false) {
                        return null;
                    }

                    ByteArrayInputStream bais = new ByteArrayInputStream (jarByteArray);
                    try {
                        JarInputStream jis = new JarInputStream (bais);
                        JarEntry entry;
                    
                        while ((entry = jis.getNextJarEntry ()) != null) {
                            if (entry.getName ().equals (name)) {
                                return jis;
                            }
                        }
                    } catch (Exception e) {
                    }

                    return null;
                }
            };

        LoaderUtils.setContextClassLoader (customLoader);
    }

    public void tearDown() {
        LoaderUtils.setContextClassLoader (LoaderUtils.getContextClassLoader ().getParent ());
        su = null;
    }

    public void testServiceProvidersFor () {
        assertNull (su.serviceProvidersFor (ServiceNoConfig.class));
        String[] expectedProviders = new String [] {ServiceNoProvider.class.getName ()};
        String[] actualProviders   = su.serviceProvidersFor (ServiceNoProvider.class);

        if (expectedProviders.length != actualProviders.length) {
            fail ("Expected " + expectedProviders.length + " providers but found " + actualProviders.length);
        }

        for (int i = 0; i < expectedProviders.length; i++) {
            assertEquals (expectedProviders[i], actualProviders[i]);
        }
    }

    public void testServiceProviderForDefaults () {
        assertNull (                        su.serviceProviderFor (ServiceNoConfig.class));
        assertSame (ProviderNoConfig.class, su.serviceProviderFor (ProviderNoConfig.class));
    }

    public void testServiceProviderForInterface () {
        try {
            Class provider = su.serviceProviderFor (ServiceNoProvider.class);
            fail ("successfully returned interface");
        } catch (BuildException e) {
            // Expected Exception caught
        } catch (Throwable t) {
            fail (t.getMessage ());
        }
    }

    public void testServiceProviderForMissingConstructor () {
        try {
            Class provider = su.serviceProviderFor (NoDefaultConstructorProvider.class);
            fail ("successfully returned class lacking default constructor");
        } catch (BuildException e) {
            // Expected Exception caught
        } catch (Throwable t) {
            fail (t.getMessage ());
        }
    }

    public void testServiceProviderForFirstValidProvider () {
        try {
            Class provider = su.serviceProviderFor (AbstractService.class);
            assertSame (provider, ValidProvider.class);
        } catch (Throwable t) {
            fail (t.getMessage ());
        }
    }

    public void testServiceProviderForSecondValidProvider () {
        try {
            ServiceUtils.Constraints c = new ServiceUtils.Constraints () {
                    public void satisfiedBy (Class provider) throws Exception {
                        if (provider == ValidProvider.class) {
                            throw new Exception ("Found class blocked by explicit constraints.");
                        }
                    }
                };

            Class provider = su.serviceProviderFor (AbstractService.class, c);
            assertSame (provider, ValidProvider2.class);
        } catch (Throwable t) {
            fail (t.getMessage ());
        }
    }

    public void testServiceProviderForAbstractService() {
        try {
            ServiceUtils.Constraints c = new ServiceUtils.Constraints () {
                    public void satisfiedBy (Class provider) throws Exception {
                        if (provider != AbstractService.class) {
                            throw new Exception ("Found class blocked by explicit constraints.");
                        }
                    }
                };

            Class provider = su.serviceProviderFor (AbstractService.class, c);
            fail ("Found abstract service provider.");
        } catch (BuildException e) {
            // Expected Exception caught
        } catch (Throwable t) {
            fail (t.getMessage ());
        }
    }

    public static class NoDefaultConstructorProvider {
        public NoDefaultConstructorProvider (int i) { // No default constructor
        }
    }

    public static class PrivateDefaultConstructorProvider {
        private PrivateDefaultConstructorProvider () {
        }
    }

    public static class ValidProvider  extends ServiceUtilsTest.AbstractService {
        public ValidProvider () {} // Explicit default constructor
    }

    public static class ValidProvider2 extends ServiceUtilsTest.AbstractService {
        // Implicit default constructor
    }

    public static class ProviderNoConfig implements ServiceNoConfig {
    };
}


Return to bug 32142

Line 0 Link Here

(-)docs/manual/CoreTypes/entities.html (+91 lines)
		1	<html>
		2
		3	<head>
		4	<meta http-equiv="Content-Language" content="en-us"></meta>
		5	<title>External Entities</title>
		6	</head>
		7
		8	<body>
		9	<h2><a name="entities">External Entities</a></h2>
		10	<h3>Description</h3>
		11	<p>
		12	The XML parser used by ant is capable of resolving parsed external
		13	entities using system identifiers and, when configured appropriately,
		14	public identifiers. These entities appear in one of the following forms:
		15	</p>
		16	<blockquote>
		17	<pre>
		18	<!ENTITY <U>Name</U> SYSTEM <U>System Identifier</U>>
		19	<!ENTITY <U>Name</U> PUBLIC <U>Public Identifier</U> <U>System Identifier</U>>
		20	</pre>
		21	</blockquote>
		22	<h3><a name="system">System Identifier</a></h3>
		23	<p>
		24	A URI that uniquely identifies the external resource whose contents will become the entity's definition. All Java protocols are supported as well as Ant's custom protocol (<A href="../protocol.html#resource">resource</A>).
		25	</p>
		26	<h3><a name="public">Public Identifier</a></h3>
		27	<p>
		28	A public identifier is an unique, but otherwise, arbitrary identifier. When using public identifiers, Ant depends upon an entity resolver identified by the JDK service "org.apache.tools.ant.helper.EntityResolver". The author of this service may provide any implementation for mapping public identifiers to InputSource objects so long as the service's implementation extends the org.apache.tools.ant.helper.EntityResolver class.
		29	</p>
		30	<p>
		31	A sample implementation for a custom entity resolver is:
		32	<blockquote>
		33	<pre>
		34	package my.org.ant.helper;
		35
		36	import org.apache.tools.ant.Project;
		37	import org.xml.sax.InputSource;
		38
		39	public class PublicEntityResolver extends org.apache.tools.ant.helper.EntityResolver {
		40	/**
		41	* Resolves XML external entities. Attempts to get the resource
		42	* using the system ID so that the most up-to-date resource is
		43	* used. However, if the system ID fails then uses the public ID
		44	* to reference a backup copy of the resource.
		45	*
		46	* @param publicId The public identifier, or <code>null</code>
		47	* if none is available.
		48	* @param systemId The system identifier provided in the XML
		49	* document. Will not be <code>null</code>.
		50	*/
		51	public InputSource resolveEntity(String publicId,
		52	String systemId) {
		53	InputSource source = super.resolveEntity(publicId, systemId);
		54
		55	if (source == null && publicId != null) {
		56	getProject().log("resolving publicId: " + publicId, Project.MSG_VERBOSE);
		57
		58	// Use the public identifier to identify entities that
		59	// I stored within the same jar as this resolver. In
		60	// principle, this will let me retrieve a resource
		61	// even when the system ID is blocked.
		62	if ("-- my public Identifier --".equals(publicId)) {
		63	String cachedResource="local/resource/my_private_resource_name";
		64
65	ClassLoader ldr = this.getClass().getClassLoader();
66	source =
67	new InputSource (ldr.getResource(cachedResource));
68	source.setPublic(publicId);
69	} else {
70	getProject().log("failed to resolve publicId: " + publicId, Project.MSG_WARN);
71	}
72	}
73
74	return source;
75	}
76	}
77
78	</pre>
79	</blockquote>
80	</p>
81	<p>
82	Installation of this custom resolver requires construction of a jar file containing, as a minimum, two files. The first file is a provider configuration file that will be placed in the jar file with the resource name 'META−INF/services/org.apache.tools.ant.helper.EntityResolver'. The content of this file is the fully qualified class name of the class implementing this service (See the JavaDoc for the java.util.jar package for full details). The second file is the Java class file named by the provider configuration file.
83	</p>
84
85	<hr>
86	<p align="center">Copyright © 2003-2004 Apache Software
87	Foundation. All rights Reserved.</p>
88
89	</body>
90	</html>
91

Line 0 Link Here

(-)docs/manual/protocol.html (+30 lines)
	1	<html>
	2
	3	<head>
	4	<meta http-equiv="Content-Language" content="en-us"></meta>
	5	<title>Ant Uniform Resource Locator (URL) Protocol</title>
	6	</head>
	7
	8	<body>
	9	<h2><a name="resource">Ant Uniform Resource Locator (URL) Protocol</a></h2>
	10	<h3>Description</h3>
	11	<p>Ant provides a custom URL protocol (<b>resource</b>) for referencing resources located via Ant's class loaders. A URL using the <b>resource</b> protocol will use the syntax, <code>resource:path</code>, where <code>path</code> names the resource. Leading slashes(/) on the <code>path</code> are automatically stripped off to match the class loader convention of using relative paths to name resources.
	12	</p>
	13	<p>
	14	Ant will search for the resource first using the current thread's context class loader. If that loader fails, Ant will then try the class loader used to load the Ant core class files. Finally, if the resource still hasn't been located, Ant will search for the resource using the system class loader.
	15	</p>
	16	<p>
	17	This protocol does not support specifying a host (//host name), port (:port number), fragment (#fragment), or query parameters (?parameters).
	18	</p>
	19	<p>
	20	The <b>resource</b> protocol may be used by any part (type, task, etc) of Ant. No type or task may change the class path referenced by the <b>resource</b> protocol except by changing the project's class path.
	21	</p>
	22	<p>
	23	In the event that the same resource is located in multiple jar files or directories, the <b>resource</b> protocol will return the first resource found when searching in the order specified by the project's classpath.
	24	</p>
	25	<hr>
	26	<p align="center">Copyright © 2003-2004 Apache Software
	27	Foundation. All rights Reserved.</p>
	28
	29	</body>
	30	</html>

Lines 26-31 Link Here

(-)src/main/org/apache/tools/ant/ProjectHelper.java (-30 / +11 lines)
26	import java.util.Vector;	26	import java.util.Vector;
27	import org.apache.tools.ant.helper.ProjectHelper2;	27	import org.apache.tools.ant.helper.ProjectHelper2;
28	import org.apache.tools.ant.util.LoaderUtils;	28	import org.apache.tools.ant.util.LoaderUtils;
		29	import org.apache.tools.ant.util.ServiceUtils;
29	import org.xml.sax.AttributeList;	30	import org.xml.sax.AttributeList;
30		31
31	/**	32	/**
Lines 182-219 Link Here
182	// automatically if in CLASSPATH, with the right META-INF/services.	183	// automatically if in CLASSPATH, with the right META-INF/services.
183	if (helper == null) {	184	if (helper == null) {
184	try {	185	try {
185	ClassLoader classLoader = LoaderUtils.getContextClassLoader();	186	String[] helperClasses = ServiceUtils.newServiceUtils().serviceProvidersFor(ProjectHelper.class);
186	InputStream is = null;	187	if (helperClasses != null) {
187	if (classLoader != null) {	188	helperClass = helperClasses [0];
188	is = classLoader.getResourceAsStream(SERVICE_ID);	189
189	}	190	if (helperClass != null) {
190	if (is == null) {	191	helper = newHelper (helperClass);
191	is = ClassLoader.getSystemResourceAsStream(SERVICE_ID);
192	}
193
194	if (is != null) {
195	// This code is needed by EBCDIC and other strange systems.
196	// It's a fix for bugs reported in xerces
197	InputStreamReader isr;
198	try {
199	isr = new InputStreamReader(is, "UTF-8");
200	} catch (java.io.UnsupportedEncodingException e) {
201	isr = new InputStreamReader(is);
202	}
203	BufferedReader rd = new BufferedReader(isr);
204
205	String helperClassName = rd.readLine();
206	rd.close();
207
208	if (helperClassName != null
209	&& !"".equals(helperClassName)) {
210
211	helper = newHelper(helperClassName);
212	}	192	}
213	}	193	}
214	} catch (Exception ex) {	194	} catch (BuildException e) {
215	System.out.println("Unable to load ProjectHelper "	195	throw e;
216	+ "from service \"" + SERVICE_ID);	196	} catch (Exception e) {
		197	throw new BuildException (e);
217	}	198	}
218	}	199	}
219		200

Line 0 Link Here

(-)src/main/org/apache/tools/ant/helper/EntityResolver.java (+159 lines)
		1	/*
		2	* Copyright 2000-2004 The Apache Software Foundation
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*
		16	*/
		17
		18	package org.apache.tools.ant.helper;
		19
		20	import java.io.File;
		21	import java.io.FileInputStream;
		22	import java.io.FileNotFoundException;
		23	import java.io.InputStream;
		24	import java.io.InputStreamReader;
		25	import org.apache.tools.ant.BuildException;
		26	import org.apache.tools.ant.Project;
		27	import org.apache.tools.ant.ProjectHelper;
		28	import org.apache.tools.ant.util.FileUtils;
		29	import org.apache.tools.ant.util.LoaderUtils;
		30	import org.xml.sax.InputSource;
		31
		32	/**
		33	* <P>Ant's default entity resolver provides for resolving relative file URLs
		34	* with respect to the current build file's directory.</P> <P>Developers who
		35	* wish to provide their own entity resolver must extend from this class.</P>
		36	*/
		37	public class EntityResolver implements org.xml.sax.EntityResolver {
		38	private File buildFileParent;
		39	private AntXMLContext context;
		40	private Project project;
		41
		42	/**
		43	* Construct an uninitialized entity resolver. Ant must call either {@link
		44	* #setContext(AntXMLContext)}, or {@link
		45	* #setProject(org.apache.tools.ant.Project)} and {@link
		46	* #setBuildFileParent(java.io.File)} before this resolver can be used.
		47	*/
		48	public EntityResolver() {
		49	}
		50
		51	/**
		52	* helper for path -> URI and URI -> path conversions.
		53	*/
		54	private static final FileUtils fu = FileUtils.newFileUtils();
		55
		56	/**
		57	* Set the Context for which this EntityResolver is working.
		58	*
		59	* @param context the Ant XML context to configure
		60	*/
		61	void setContext(AntXMLContext context) {
		62	this.context = context;
		63	}
		64
65	/**
66	* <P>Set the Project for which this EntityResolver is working.</P> <P>NOTE:
67	* The project set by this method is ignored once {@link
68	* #setContext(AntXMLContext)} has been called.</P>
69	*
70	* @param project the ANT project to configure.
71	*/
72	void setProject(Project project) {
73	this.project = project;
74	}
75
76	/**
77	* <P>Set the build file parent for resolving relative file URLs.</P>
78	* <P>NOTE: The build file parent(directory) set by this method is ignored
79	* once {@link #setContext(AntXMLContext)} has been called.</P>
80	*
81	* @param file the project's build directory
82	*/
83	void setBuildFileParent(File buildFileParent) {
84	this.buildFileParent = buildFileParent;
85	}
86
87	/**
88	* Get the Project for which this EntityResolver is working.
89	*
90	* @return the ANT Project
91	*/
92
93	public Project getProject() {
94	if (context == null) {
95	return project;
96	}
97
98	return context.getProject();
99	}
100
101	/**
102	* Get the BuildFileParent for which this EntityResolver is working.
103	*
104	* @return the ANT BuildFileParent
105	*/
106
107	public File getBuildFileParent() {
108	if (context == null) {
109	return buildFileParent;
110	}
111
112	return context.getBuildFileParent();
113	}
114
115	/**
116	* Get the class loader for this context.
117	*/
118	public ClassLoader getClassLoader() {
119	return LoaderUtils.getContextClassLoader();
120	}
121
122	/**
123	* Resolves file URIs relative to the build file.
124	*
125	* @param publicId The public identifier, or <code>null</code> if none is
126	* available. Ignored in this implementation.
127	* @param systemId The system identifier provided in the XML document. Will
128	* not be <code>null</code>.
129	*/
130	public InputSource resolveEntity(String publicId,
131	String systemId) {
132	getProject().log("resolving systemId: " + systemId, Project.MSG_VERBOSE);
133
134	if (systemId.startsWith("file:")) {
135	String path = fu.fromURI(systemId);
136
137	File file = new File(path);
138	if (!file.isAbsolute()) {
139	file = fu.resolveFile(getBuildFileParent(), path);
140	}
141	try {
142	getProject().log("resolved systemId: " + systemId
143	+ " as " + file.getAbsolutePath(),
144	Project.MSG_DEBUG);
145
146	InputSource inputSource =
147	new InputSource(new InputStreamReader(new FileInputStream(file)));
148	inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
149	return inputSource;
150	} catch (FileNotFoundException fne) {
151	getProject().log(file.getAbsolutePath() + " could not be found",
152	Project.MSG_WARN);
153	}
154	}
155
156	// use default if not file or file not found
157	return null;
158	}
159	}

Lines 36-41 Link Here

(-)src/main/org/apache/tools/ant/helper/ProjectHelper2.java (-24 / +21 lines)
36		36
37	import org.apache.tools.ant.util.JAXPUtils;	37	import org.apache.tools.ant.util.JAXPUtils;
38	import org.apache.tools.ant.util.FileUtils;	38	import org.apache.tools.ant.util.FileUtils;
		39	import org.apache.tools.ant.util.ServiceUtils;
39		40
40	import org.apache.tools.ant.ProjectHelper;	41	import org.apache.tools.ant.ProjectHelper;
41	import org.apache.tools.ant.Project;	42	import org.apache.tools.ant.Project;
Lines 66-71 Link Here
66	*/	67	*/
67	private static FileUtils fu = FileUtils.newFileUtils();	68	private static FileUtils fu = FileUtils.newFileUtils();
68		69
		70	static {
		71	URLStreamHandlerFactory factory =
		72	(URLStreamHandlerFactory) ServiceUtils.newServiceUtils()
		73	.serviceFor (URLStreamHandlerFactory.class);
		74
		75	try {
		76	java.net.URL.setURLStreamHandlerFactory (factory);
		77	} catch (Error e) {
		78	// Error will occur if both ProjectHelper2 and ProjectHelperImpl are loaded
		79	}
		80	}
		81
69	/**	82	/**
70	* Parse an unknown element from a url	83	* Parse an unknown element from a url
71	*	84	*
Lines 377-382 Link Here
377	private Stack antHandlers = new Stack();	390	private Stack antHandlers = new Stack();
378	private AntHandler currentHandler = null;	391	private AntHandler currentHandler = null;
379	private AntXMLContext context;	392	private AntXMLContext context;
		393	private EntityResolver entityResolver;
380		394
381	/**	395	/**
382	* Creates a new RootHandler instance.	396	* Creates a new RootHandler instance.
Lines 388-393 Link Here
388	currentHandler = rootHandler;	402	currentHandler = rootHandler;
389	antHandlers.push(currentHandler);	403	antHandlers.push(currentHandler);
390	this.context = context;	404	this.context = context;
		405
		406	this.entityResolver =
		407	(EntityResolver) ServiceUtils.newServiceUtils()
		408	.serviceFor (org.apache.tools.ant.helper.EntityResolver.class);
		409
		410	entityResolver.setContext(context);
391	}	411	}
392		412
393	/**	413	/**
Lines 410-439 Link Here
410	*/	430	*/
411	public InputSource resolveEntity(String publicId,	431	public InputSource resolveEntity(String publicId,
412	String systemId) {	432	String systemId) {
413		433	return entityResolver.resolveEntity(publicId, systemId);
414	context.getProject().log("resolving systemId: "
415	+ systemId, Project.MSG_VERBOSE);
416
417	if (systemId.startsWith("file:")) {
418	String path = fu.fromURI(systemId);
419
420	File file = new File(path);
421	if (!file.isAbsolute()) {
422	file = fu.resolveFile(context.getBuildFileParent(), path);
423	}
424	try {
425	InputSource inputSource =
426	new InputSource(new FileInputStream(file));
427	inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
428	return inputSource;
429	} catch (FileNotFoundException fne) {
430	context.getProject().log(file.getAbsolutePath()
431	+ " could not be found", Project.MSG_WARN);
432	}
433
434	}
435	// use default if not file or file not found
436	return null;
437	}	434	}
438		435
439	/**	436	/**

Lines 35-40 Link Here

(-)src/main/org/apache/tools/ant/helper/ProjectHelperImpl.java (-35 / +26 lines)
35	import org.apache.tools.ant.TaskContainer;	35	import org.apache.tools.ant.TaskContainer;
36	import org.apache.tools.ant.UnknownElement;	36	import org.apache.tools.ant.UnknownElement;
37	import org.apache.tools.ant.util.FileUtils;	37	import org.apache.tools.ant.util.FileUtils;
		38	import org.apache.tools.ant.util.ServiceUtils;
38	import org.apache.tools.ant.util.JAXPUtils;	39	import org.apache.tools.ant.util.JAXPUtils;
39	import org.xml.sax.AttributeList;	40	import org.xml.sax.AttributeList;
40	import org.xml.sax.DocumentHandler;	41	import org.xml.sax.DocumentHandler;
Lines 83-88 Link Here
83	*/	84	*/
84	private static FileUtils fu = FileUtils.newFileUtils();	85	private static FileUtils fu = FileUtils.newFileUtils();
85		86
		87	static {
		88	URLStreamHandlerFactory factory =
		89	(URLStreamHandlerFactory) ServiceUtils.newServiceUtils()
		90	.serviceFor (URLStreamHandlerFactory.class);
		91
		92	try {
		93	java.net.URL.setURLStreamHandlerFactory (factory);
		94	} catch (Error e) {
		95	// Error will occur if both ProjectHelper2 and ProjectHelperImpl are loaded
		96	}
		97	}
		98
86	/**	99	/**
87	* default constructor	100	* default constructor
88	*/	101	*/
Lines 125-133 Link Here
125	inputSource.setSystemId(uri);	138	inputSource.setSystemId(uri);
126	project.log("parsing buildfile " + buildFile + " with URI = "	139	project.log("parsing buildfile " + buildFile + " with URI = "
127	+ uri, Project.MSG_VERBOSE);	140	+ uri, Project.MSG_VERBOSE);
		141
		142	EntityResolver entityResolver =
		143	(EntityResolver) ServiceUtils.newServiceUtils()
		144	.serviceFor (org.apache.tools.ant.helper.EntityResolver.class);
		145
		146	entityResolver.setProject(project);
		147	entityResolver.setBuildFileParent(buildFileParent);
		148
128	HandlerBase hb = new RootHandler(this);	149	HandlerBase hb = new RootHandler(this);
129	parser.setDocumentHandler(hb);	150	parser.setDocumentHandler(hb);
130	parser.setEntityResolver(hb);	151	parser.setEntityResolver(entityResolver);
131	parser.setErrorHandler(hb);	152	parser.setErrorHandler(hb);
132	parser.setDTDHandler(hb);	153	parser.setDTDHandler(hb);
133	parser.parse(inputSource);	154	parser.parse(inputSource);
Lines 143-148 Link Here
143	be.setLocation(location);	164	be.setLocation(location);
144	}	165	}
145	throw be;	166	throw be;
		167	} else if (t == null) {
		168	t = exc;
146	}	169	}
147		170
148	throw new BuildException(exc.getMessage(), t, location);	171	throw new BuildException(exc.getMessage(), t, location);
Lines 150-155 Link Here
150	Throwable t = exc.getException();	173	Throwable t = exc.getException();
151	if (t instanceof BuildException) {	174	if (t instanceof BuildException) {
152	throw (BuildException) t;	175	throw (BuildException) t;
		176	} else if (t == null) {
		177	t = exc;
153	}	178	}
154	throw new BuildException(exc.getMessage(), t);	179	throw new BuildException(exc.getMessage(), t);
155	} catch (FileNotFoundException exc) {	180	} catch (FileNotFoundException exc) {
Lines 279-318 Link Here
279		304
280	public RootHandler(ProjectHelperImpl helperImpl) {	305	public RootHandler(ProjectHelperImpl helperImpl) {
281	this.helperImpl = helperImpl;	306	this.helperImpl = helperImpl;
282	}
283
284	/**
285	* Resolves file: URIs relative to the build file.
286	*
287	* @param publicId The public identifier, or <code>null</code>
288	* if none is available. Ignored in this
289	* implementation.
290	* @param systemId The system identifier provided in the XML
291	* document. Will not be <code>null</code>.
292	*/
293	public InputSource resolveEntity(String publicId,
294	String systemId) {
295
296	helperImpl.project.log("resolving systemId: " + systemId, Project.MSG_VERBOSE);
297
298	if (systemId.startsWith("file:")) {
299	String path = fu.fromURI(systemId);
300
301	File file = new File(path);
302	if (!file.isAbsolute()) {
303	file = fu.resolveFile(helperImpl.buildFileParent, path);
304	}
305	try {
306	InputSource inputSource = new InputSource(new FileInputStream(file));
307	inputSource.setSystemId(fu.toURI(file.getAbsolutePath()));
308	return inputSource;
309	} catch (FileNotFoundException fne) {
310	helperImpl.project.log(file.getAbsolutePath() + " could not be found",
311	Project.MSG_WARN);
312	}
313	}
314	// use default if not file or file not found
315	return null;
316	}	307	}
317		308
318	/**	309	/**

Line 0 Link Here

(-)src/main/org/apache/tools/ant/protocol/resource/Handler.java (+94 lines)
		1	/*
		2	* Copyright 2000-2004 The Apache Software Foundation
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*
		16	*/
		17
		18	package org.apache.tools.ant.protocol.resource;
		19
		20	import java.io.IOException;
		21	import java.net.URL;
		22
		23	/**
		24	* The URL stream handler for the resource protocol. This handler parses the
		25	* string representation of a URL storing the various elements within a provided
		26	* URL object. It also provides the factory for creating a connection specific
		27	* to a URL based on this protocol.
		28	*/
		29	public final class Handler extends java.net.URLStreamHandler {
		30	/**
		31	* Default constructor. Creates a component used by the java.net framework
		32	* to add support for the <code>resource</code> protocol.
		33	*/
		34	public Handler () {
		35	}
		36
		37	/**
		38	* Determines whether two URLs reference the same resource.
		39	*/
		40	protected boolean equals(URL u1, URL u2) {
		41	String path1 = u1.getPath();
		42	String path2 = u2.getPath();
		43	return (super.equals(u1, u2) &&
		44	path1 == null? path2 == null: path1.equals(path2));
		45	}
		46
		47	/**
		48	* <p>Parses the string representation of a <code>URL</code> into a
		49	* <code>URL</code> object.</P> <p>If there is any inherited context, then
		50	* it has already been copied into the <code>URL</code> argument.</P>
		51	* <p>Uses the <code>parseURL</code> method of <code>URLStreamHandler</code>
		52	* to parse the string representation as if it were an <code>http</code>
		53	* specification. Standard components, such as the authority and query, must
		54	* not be present for the <code>spec</code> to be legal.</P>
		55	*
		56	* @param u the <code>URL</code> to receive the result of parsing the spec.
		57	* @param spec the <code>String</code> representing the URL that must be
		58	* parsed.
		59	* @param start the character index at which to begin parsing. This is just
		60	* past the '<code>:</code>' (if there is one) that specifies the
		61	* determination of the protocol name.
		62	* @param limit the character position to stop parsing at. This is the end
		63	* of the string or the position of the "<code>#</code>" character, if
		64	* present. All information after the sharp sign indicates an anchor.
65	*/
66	protected void parseURL (URL url, String spec, int start, int finish) {
67	super.parseURL (url, spec, start, finish);
68
69	if (url.getAuthority () != null) {
70	throw new RuntimeException ("resource: protocol does not support "
71	+ "setting the URL's authority "
72	+ "(i.e. host, port, user, or password)");
73	}
74
75	if (url.getQuery () != null) {
76	throw new RuntimeException ("resource: protocol does not "
77	+ "support query parameters.");
78	}
79	}
80
81	/**
82	* Opens a connection to the object referenced by
83	* <code>url</code>.
84	*
85	* @param url the URL that this connects to.
86	* @return an object specific to a <code>resource:URL</code> that extends
87	* from the {@link java.net.URLConnection} class.
88	* @exception IOException if an I/O error occurs while opening the
89	* connection.
90	*/
91	protected java.net.URLConnection openConnection(URL url) throws IOException {
92	return new ResourceURLConnection(url);
93	}
94	}

Line 0 Link Here

(-)src/main/org/apache/tools/ant/util/ServiceUtils.java (+384 lines)
		1	/*
		2	* Copyright 2001-2004 The Apache Software Foundation
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*
		16	*/
		17
		18	package org.apache.tools.ant.util;
		19
		20	import java.io.BufferedReader;
		21	import java.io.InputStream;
		22	import java.io.InputStreamReader;
		23	import java.lang.reflect.Modifier;
		24	import java.lang.reflect.Constructor;
		25	import java.util.HashMap;
		26	import java.util.List;
		27	import java.util.Map;
		28	import java.util.Vector;
		29	import org.apache.tools.ant.BuildException;
		30	import org.apache.tools.ant.util.LoaderUtils;
		31
		32	/**
		33	* A collection of methods that implement the JDK 1.3 service discovery
		34	* mechanism. While this API was introduced in JDK 1.3, it's implementation is
		35	* fully compatible with JDK 1.2.
		36	*/
		37
		38	public class ServiceUtils {
		39	private static Map knownServiceProviderClassNames = new HashMap ();
		40
		41	/**
		42	* Factory for constructing a new ServiceUtils instance.
		43	*
		44	* @return a new instance of ServiceUtils.
		45	*/
		46	public static ServiceUtils newServiceUtils() {
		47	return new ServiceUtils();
		48	}
		49
		50	/**
		51	* The default constructor.
		52	*/
		53	protected ServiceUtils() {
		54	}
		55
		56	/**
		57	* Gets the service providers for the specified service. The service's
		58	* fully qualified class name is used to construct the name of a service
		59	* configuration file that should be found using either the context or
		60	* system class loader. This configuration file should contain one, or
		61	* more, class names identifying providers of the specified service.
		62	*
		63	* This method simply locates and parses the configuration file without any
		64	* consideration for the validity of the class names found therein.
65	*
66	* @param service the interface or class that the service provider must
67	* implement
68	* @return An array of service provider class names that are presumed to
69	* implement the service; null when no providers were found.
70	*
71	* @since Ant1.6
72	* @exception BuildException if the provider class can not be loaded
73	*/
74	public String[] serviceProvidersFor(Class service) throws BuildException {
75	String serviceID = "META-INF/services/" + service.getName ();
76	String[] classNames = (String[]) knownServiceProviderClassNames.get(serviceID);
77
78	if (classNames == null) {
79	try {
80	ClassLoader classLoader = LoaderUtils.getContextClassLoader();
81	InputStream is = null;
82	if (classLoader != null) {
83	is = classLoader.getResourceAsStream(serviceID);
84	}
85	if (is == null) {
86	is = ClassLoader.getSystemResourceAsStream(serviceID);
87	}
88
89	if (is != null) {
90	// This code is needed by EBCDIC and other strange systems.
91	// It's a fix for bugs reported in xerces
92	InputStreamReader isr;
93	try {
94	isr = new InputStreamReader(is, "UTF-8");
95	} catch (java.io.UnsupportedEncodingException e) {
96	isr = new InputStreamReader(is);
97	}
98	BufferedReader rd = new BufferedReader(isr);
99
100	// This simple parser implements the Service Provider syntax
101	// described in the JAR Specification.
102	String className = null;
103	List providerClasses = new Vector ();
104	while ((className = rd.readLine()) != null) {
105	// Strip off comment beginning with first pound sign (#).
106	int pound = className.indexOf ('#');
107
108	if (pound > -1) {
109	className = className.substring (0, pound);
110	}
111
112	// Ignore spaces and tabs
113	className = className.trim ();
114
115	if (!"".equals (className)) {
116	providerClasses.add (className);
117	}
118	}
119	rd.close();
120
121	if (providerClasses.size () > 0) {
122	classNames = new String [providerClasses.size ()];
123	providerClasses.toArray (classNames);
124	knownServiceProviderClassNames.put(serviceID, classNames);
125	}
126	}
127	} catch (Exception ex) {
128	throw new BuildException("Unable to find service for \""
129	+ serviceID + "\"", ex);
130	}
131	}
132
133	return classNames;
134	}
135
136	/**
137	* A constraint based selector to pick one of possibly several service
138	* provider classes. This class represents an extension to the JDK 1.3
139	* service discovery mechanism.
140	*/
141	public interface Constraints {
142	/**
143	* Determines whether the specified service provider class satisfies all
144	* of the constraints imposed by the current request.
145	*
146	* @throws Exception thrown when the provider does not satisfy all of
147	* the constraints.
148	*/
149	public void satisfiedBy (Class provider) throws Exception;
150	}
151
152	/**
153	* Gets the service provider class that provides the specified service.
154	* This service provider class must meet all of the following requirements.
155	* <OL><LI>It must have been named in the service provider configuration
156	* file.</LI>
157	* <LI>It must be assignable to the service class (that is, it either
158	* implements or extends the service class).</LI>
159	* <LI>It must provide a public default constructor.</LI>
160	* <LI>It must satisfy the optional constraints parameter.</LI></OL>
161	*
162	* When no service provider can be found satisfying the preceeding
163	* requirements. A check will be made to see if the service class is itself
164	* instantiable as the service provider. For this to be true, the following
165	* requirements must be met.
166	* <OL><LI>It must not be an interface or abstract class.</LI>
167	* <LI>It must provide a public default constructor.</LI>
168	* <LI>It must satisfy the optional constraints parameter.</LI></OL>
169	*
170	* @param service the interface or class that the service provider must
171	* implement
172	* @param constraints optional constraints that can be used to select one of
173	* several possible service provider classes. The first class, in order in
174	* which they were listed in the service provider configuration file, to
175	* satisfy all of the constraints will be returned.
176	* @return The class providing the service subject to the constraints; null
177	* when no providers were found.
178	*
179	* @since Ant1.6
180	* @exception BuildException if no provider classes were found that
181	* satisfied all of the constraints
182	*/
183	public Class serviceProviderFor(Class service,
184	Constraints constraints) throws BuildException {
185	String[] classNames = serviceProvidersFor(service);
186
187	// Use lazy construction to avoid creating a StringBuffer when the first
188	// provider satisfies all of the constraints.
189	StringBuffer status = null;
190
191	if (classNames != null) {
192	ClassLoader classLoader = LoaderUtils.getContextClassLoader();
193
194	for (int i = 0; i < classNames.length; i++) {
195	String className = classNames [i];
196	Class provider = null;
197
198	// Try to load the provider. If not loaded, continue with next provider.
199	try {
200	provider = classLoader.loadClass(className);
201	} catch (Exception e) {
202	try {
203	provider = Class.forName(className);
204	} catch (Exception ex) {
205	status = addStatusMsg(status, service,
206	" Unable to find class named '"
207	+ className + "'.");
208	continue;
209	}
210	}
211
212	String errMsg = validateProvider (provider, service, constraints);
213
214	if (errMsg == null) {
215	return provider;
216	}
217
218	status = addStatusMsg(status, service, errMsg);
219	}
220	}
221
222	// if no valid service providers found in the configuration file, throw
223	// the error
224	if (status != null) {
225	throw new BuildException(status.toString ());
226	}
227
228	// No service providers found in the configuration file. See if it is
229	// possible to use the service class as a minimal provider
230	String errMsg = validateProvider (service, service, constraints);
231
232	if (errMsg == null) {
233	return service;
234	}
235
236	return null;
237	}
238
239	/**
240	* Gets the service provider class that provides the specified service.
241	* This service provider class must meet all of the following requirements.
242	* <OL><LI>It must have been named in the service provider configuration
243	* file.</LI>
244	* <LI>It must be assignable to the service class (that is, it either
245	* implements or extends the service class).</LI>
246	* <LI>It must provide a public default constructor.</LI></OL>
247	*
248	* @param service the interface or class that the service provider must
249	* implement
250	* @return The class providing the service; null when no service provider
251	* was found.
252	*
253	* @since Ant1.6
254	* @exception BuildException if the provider class can not be loaded
255	*/
256	public Class serviceProviderFor(Class service) throws BuildException {
257	return serviceProviderFor(service, null);
258	}
259
260	/**
261	* Gets the service provider instance for the specified service.
262	*
263	* @param service the interface or class that the service provider must
264	* implement
265	* @param constraints optional constraints that can be used to select one of
266	* several possible service provider classes. The first class, in order in
267	* which they were listed in the service provider configuration file, to
268	* satisfy all of the constraints will be returned.
269	* @return The instance providing the service
270	*
271	* @since Ant1.6
272	* @exception BuildException if the instance can not created
273	*/
274	public Object serviceFor(Class service,
275	Constraints constraints) throws BuildException {
276	try {
277	return serviceProviderFor(service, constraints).newInstance ();
278	} catch (BuildException e) {
279	throw e;
280	} catch (Exception e) {
281	throw new BuildException("The service provider for "
282	+ service.getClass ()
283	+ " could not be instantiated.");
284	}
285	}
286
287	/**
288	* Gets the service provider instance for the specified service.
289	*
290	* @param service the interface or class that the service provider must
291	* implement
292	* @return The instance providing the service
293	*
294	* @since Ant1.6
295	* @exception BuildException if the instance can not created
296	*/
297	public Object serviceFor(Class service) throws BuildException {
298	return serviceFor(service, null);
299	}
300
301	/**
302	* Used internally by serviceProviderFor. Assembles a multi-line exception
303	* message over the course of several calls.
304	*/
305	private StringBuffer addStatusMsg (StringBuffer allMessages,
306	Class service, String message) {
307	if (message != null) {
308	if (allMessages == null) {
309	allMessages = new StringBuffer ();
310	allMessages.append ("Attempting to locate service provider for ");
311	allMessages.append (service.getName ());
312	allMessages.append ("\n");
313	}
314
315	allMessages.append (" ");
316	allMessages.append (message);
317	allMessages.append ("\n");
318	}
319
320	return allMessages;
321	}
322
323	/**
324	* Validate the indicated provider by checking that it satisfies all
325	* internal and external provider constraints. If anything is wrong, return
326	* a string suitable for throwing in an exception.
327	*
328	* @param provider the class that is being validated as the service provider
329	* @param service the interface or class that the service provider must
330	* implement
331	* @param constraints optional constraints that can be used to select one of
332	* several possible service provider classes. The first class, in order in
333	* which they were listed in the service provider configuration file, to
334	* satisfy all of the constraints will be returned.
335	* @return a string suitable for use as the message in an exception
336	*
337	* @since Ant1.6
338	*/
339	private String validateProvider(Class provider, Class service, Constraints constraints) {
340	// Validate the provider class
341	if (provider.isInterface ()){
342	return provider.getName() + " can not be a provider as it is an interface.";
343	} else if (Modifier.isAbstract(provider.getModifiers())) {
344	return provider.getName() + " can not be a provider as it is abstract.";
345	} else if (provider.isArray()) {
346	return provider.getName() + " can not be a provider as it is an array.";
347	} else if (provider.isPrimitive()) {
348	return provider.getName() + " can not be a provider as it is primitive.";
349	} else if (service.isAssignableFrom(provider) == false) {
350	return provider.getName() + " can not be cast to " + service.getName ();
351	}
352
353	// Validate the provider's constructor
354
355	// Use getDeclaredConstructors, not getConstructor nor getConstructors,
356	// to get constructor when class is using implicit default constructor.
357	foundPublicDefaultConstructor: {
358	Constructor[] constructors = provider.getDeclaredConstructors();
359
360	for (int i = 0; i < constructors.length; i++) {
361	Constructor c = constructors [i];
362	if (Modifier.isPublic (c.getModifiers ())
363	&& c.getParameterTypes ().length == 0) {
364	break foundPublicDefaultConstructor;
365	}
366	}
367
368	return "No default constructor for " + provider.getName();
369	}
370
371	// This provider satisfies the built-in constraints.
372
373	// if the caller provided custom constraints, check them.
374	if (constraints != null) {
375	try {
376	constraints.satisfiedBy(provider);
377	} catch (Exception e) {
378	return e.getMessage ();
379	}
380	}
381
382	return null; // valid provider
383	}
384	}

Line 0 Link Here

(-)src/testcases/org/apache/tools/ant/util/ServiceUtilsTest.java (+236 lines)
		1	/*
		2	* Copyright 2001-2004 The Apache Software Foundation
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*
		16	*/
		17
		18	package org.apache.tools.ant.util;
		19
		20	import java.io.*;
		21	import java.util.jar.*;
		22
		23	import junit.framework.TestCase;
		24
		25	import org.apache.tools.ant.util.LoaderUtils;
		26	import org.apache.tools.ant.BuildException;
		27
		28	import java.lang.reflect.Constructor;
		29	import java.lang.reflect.Modifier;
		30
		31	/**
		32	* Tests for org.apache.tools.ant.util.ServiceUtils.
		33	*
		34	*/
		35	public class ServiceUtilsTest extends TestCase {
		36
		37	private ServiceUtils su;
		38
		39	public ServiceUtilsTest(String name) {
		40	super(name);
		41	}
		42
		43	interface ServiceNoProvider {};
		44
		45	abstract static class AbstractService {} {
		46	}
		47
		48	interface ServiceNoConfig {};
		49
		50	private byte[] getJarContents () {
		51	ByteArrayOutputStream baos = new ByteArrayOutputStream ();
		52
		53	try {
		54	JarOutputStream jos = new JarOutputStream (baos);
		55	PrintStream ps = new PrintStream (jos, true);
		56
		57	jos.putNextEntry (new JarEntry ("META-INF/services/" + ServiceNoProvider.class.getName ()));
		58	ps.println ("# comment"); // legal comment
		59	ps.println (" # comment"); // ignorable whitespace with comment
		60	ps.println (ServiceNoProvider.class.getName () + "# comment"); // Interface, not instantiable
		61	ps.println (""); // blank line
		62
		63	jos.putNextEntry (new JarEntry ("META-INF/services/" + NoDefaultConstructorProvider.class.getName ()));
		64	ps.println (NoDefaultConstructorProvider.class.getName ());
65
66	jos.putNextEntry (new JarEntry ("META-INF/services/" + PrivateDefaultConstructorProvider.class.getName ()));
67	ps.println (PrivateDefaultConstructorProvider.class.getName ());
68
69	jos.putNextEntry (new JarEntry ("META-INF/services/" + AbstractService.class.getName ()));
70	ps.println (NoDefaultConstructorProvider.class.getName ()); // not valid (wrong provider)
71	ps.println (AbstractService .class.getName ()); // not valid (abstract)
72	ps.println (ValidProvider .class.getName ()); // valid
73	ps.println (ValidProvider2 .class.getName ()); // also valid
74	ps.close ();
75	jos.close ();
76	baos.close ();
77	} catch (IOException e) {
78	e.printStackTrace ();
79	}
80
81	return baos.toByteArray ();
82	}
83
84	public void setUp() {
85	su = ServiceUtils.newServiceUtils();
86
87	final byte[] jarByteArray = getJarContents ();
88
89	// This ClassLoader provides a custom getResourcesAsStream method that can retrieve the
90	// service configuration files from the custom jar file byte array. It does not support
91	// loading classes from that source. It depends upon its parent to load classes.
92	ClassLoader customLoader = new ClassLoader (LoaderUtils.getContextClassLoader ()) {
93	public InputStream getResourceAsStream(String name) {
94	InputStream is = super.getResourceAsStream(name);
95
96	if (is != null) {
97	return is;
98	}
99
100	if (name.startsWith ("META-INF/services/") == false) {
101	return null;
102	}
103
104	ByteArrayInputStream bais = new ByteArrayInputStream (jarByteArray);
105	try {
106	JarInputStream jis = new JarInputStream (bais);
107	JarEntry entry;
108
109	while ((entry = jis.getNextJarEntry ()) != null) {
110	if (entry.getName ().equals (name)) {
111	return jis;
112	}
113	}
114	} catch (Exception e) {
115	}
116
117	return null;
118	}
119	};
120
121	LoaderUtils.setContextClassLoader (customLoader);
122	}
123
124	public void tearDown() {
125	LoaderUtils.setContextClassLoader (LoaderUtils.getContextClassLoader ().getParent ());
126	su = null;
127	}
128
129	public void testServiceProvidersFor () {
130	assertNull (su.serviceProvidersFor (ServiceNoConfig.class));
131	String[] expectedProviders = new String [] {ServiceNoProvider.class.getName ()};
132	String[] actualProviders = su.serviceProvidersFor (ServiceNoProvider.class);
133
134	if (expectedProviders.length != actualProviders.length) {
135	fail ("Expected " + expectedProviders.length + " providers but found " + actualProviders.length);
136	}
137
138	for (int i = 0; i < expectedProviders.length; i++) {
139	assertEquals (expectedProviders[i], actualProviders[i]);
140	}
141	}
142
143	public void testServiceProviderForDefaults () {
144	assertNull ( su.serviceProviderFor (ServiceNoConfig.class));
145	assertSame (ProviderNoConfig.class, su.serviceProviderFor (ProviderNoConfig.class));
146	}
147
148	public void testServiceProviderForInterface () {
149	try {
150	Class provider = su.serviceProviderFor (ServiceNoProvider.class);
151	fail ("successfully returned interface");
152	} catch (BuildException e) {
153	// Expected Exception caught
154	} catch (Throwable t) {
155	fail (t.getMessage ());
156	}
157	}
158
159	public void testServiceProviderForMissingConstructor () {
160	try {
161	Class provider = su.serviceProviderFor (NoDefaultConstructorProvider.class);
162	fail ("successfully returned class lacking default constructor");
163	} catch (BuildException e) {
164	// Expected Exception caught
165	} catch (Throwable t) {
166	fail (t.getMessage ());
167	}
168	}
169
170	public void testServiceProviderForFirstValidProvider () {
171	try {
172	Class provider = su.serviceProviderFor (AbstractService.class);
173	assertSame (provider, ValidProvider.class);
174	} catch (Throwable t) {
175	fail (t.getMessage ());
176	}
177	}
178
179	public void testServiceProviderForSecondValidProvider () {
180	try {
181	ServiceUtils.Constraints c = new ServiceUtils.Constraints () {
182	public void satisfiedBy (Class provider) throws Exception {
183	if (provider == ValidProvider.class) {
184	throw new Exception ("Found class blocked by explicit constraints.");
185	}
186	}
187	};
188
189	Class provider = su.serviceProviderFor (AbstractService.class, c);
190	assertSame (provider, ValidProvider2.class);
191	} catch (Throwable t) {
192	fail (t.getMessage ());
193	}
194	}
195
196	public void testServiceProviderForAbstractService() {
197	try {
198	ServiceUtils.Constraints c = new ServiceUtils.Constraints () {
199	public void satisfiedBy (Class provider) throws Exception {
200	if (provider != AbstractService.class) {
201	throw new Exception ("Found class blocked by explicit constraints.");
202	}
203	}
204	};
205
206	Class provider = su.serviceProviderFor (AbstractService.class, c);
207	fail ("Found abstract service provider.");
208	} catch (BuildException e) {
209	// Expected Exception caught
210	} catch (Throwable t) {
211	fail (t.getMessage ());
212	}
213	}
214
215	public static class NoDefaultConstructorProvider {
216	public NoDefaultConstructorProvider (int i) { // No default constructor
217	}
218	}
219
220	public static class PrivateDefaultConstructorProvider {
221	private PrivateDefaultConstructorProvider () {
222	}
223	}
224
225	public static class ValidProvider extends ServiceUtilsTest.AbstractService {
226	public ValidProvider () {} // Explicit default constructor
227	}
228
229	public static class ValidProvider2 extends ServiceUtilsTest.AbstractService {
230	// Implicit default constructor
231	}
232
233	public static class ProviderNoConfig implements ServiceNoConfig {
234	};
235	}
236