https://ant.apache.org/: master POM (The Apache Software Foundation) 
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      https://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.types.resources;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Reference;
import org.apache.tools.ant.types.Resource;
import org.apache.tools.ant.util.FileUtils;


Exposes a URL as a Resource.

Since:Ant 1.7
/**
 * Exposes a URL as a Resource.
 * @since Ant 1.7
 */
public class URLResource extends Resource implements URLProvider {
    private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();
    private static final int NULL_URL
        = Resource.getMagicNumber("null URL".getBytes());

    private URL url;
    private URLConnection conn;
    private URL baseURL;
    private String relPath;

    
Default constructor.

/**
     * Default constructor.
     */
    public URLResource() {
    }

    
Convenience constructor.

Params:
  • u – the URL to expose.
/**
     * Convenience constructor.
     * @param u the URL to expose.
     */
    public URLResource(URL u) {
        setURL(u);
    }

    
Convenience constructor.

Params:
  • u – holds the URL to expose.
/**
     * Convenience constructor.
     * @param u holds the URL to expose.
     */
    public URLResource(URLProvider u) {
        setURL(u.getURL());
    }

    
Convenience constructor.

Params:
  • f – the File to set as a URL.
/**
     * Convenience constructor.
     * @param f the File to set as a URL.
     */
    public URLResource(File f) {
        setFile(f);
    }

    
String constructor for Ant attribute introspection.

Params:
  • u – String representation of this URL.
See Also:
/**
     * String constructor for Ant attribute introspection.
     * @param u String representation of this URL.
     * @see org.apache.tools.ant.IntrospectionHelper
     */
    public URLResource(String u) {
        this(newURL(u));
    }

    
Set the URL for this URLResource.

Params:
  • u – the URL to expose.
/**
     * Set the URL for this URLResource.
     * @param u the URL to expose.
     */
    public synchronized void setURL(URL u) {
        checkAttributesAllowed();
        url = u;
    }

    
Set the URL from a File.

Params:
  • f – the File to set as a URL.
/**
     * Set the URL from a File.
     * @param f the File to set as a URL.
     */
    public synchronized void setFile(File f) {
        try {
            setURL(FILE_UTILS.getFileURL(f));
        } catch (MalformedURLException e) {
            throw new BuildException(e);
        }
    }

    
Base URL which combined with the relativePath attribute defines
the URL.

Params:
  • base – URL
Since:Ant 1.8.0
/**
     * Base URL which combined with the relativePath attribute defines
     * the URL.
     * @param base URL
     * @since Ant 1.8.0
     */
    public synchronized void setBaseURL(URL base) {
        checkAttributesAllowed();
        if (url != null) {
            throw new BuildException("can't define URL and baseURL attribute");
        }
        baseURL = base;
    }

    
Relative path which combined with the baseURL attribute defines
the URL.

Params:
  • r – String
Since:Ant 1.8.0
/**
     * Relative path which combined with the baseURL attribute defines
     * the URL.
     * @param r String
     * @since Ant 1.8.0
     */
    public synchronized void setRelativePath(String r) {
        checkAttributesAllowed();
        if (url != null) {
            throw new BuildException("can't define URL and relativePath"
                                     + " attribute");
        }
        relPath = r;
    }


    
Get the URL used by this URLResource.

Returns:a URL object.
/**
     * Get the URL used by this URLResource.
     * @return a URL object.
     */
    public synchronized URL getURL() {
        if (isReference()) {
            return getRef().getURL();
        }
        if (url == null) {
            if (baseURL != null) {
                if (relPath == null) {
                    throw new BuildException("must provide relativePath"
                                             + " attribute when using baseURL.");
                }
                try {
                    url = new URL(baseURL, relPath);
                } catch (MalformedURLException e) {
                    throw new BuildException(e);
                }
            }
        }
        return url;
     }

    
Overrides the super version.

Params:
  • r – the Reference to set.
/**
     * Overrides the super version.
     * @param r the Reference to set.
     */
    public synchronized void setRefid(Reference r) {
        //not using the accessor in this case to avoid side effects
        if (url != null || baseURL != null || relPath != null) {
            throw tooManyAttributes();
        }
        super.setRefid(r);
    }

    
Get the name of this URLResource
(its file component minus the leading separator).

Returns:the name of this resource.
/**
     * Get the name of this URLResource
     * (its file component minus the leading separator).
     * @return the name of this resource.
     */
    public synchronized String getName() {
        if (isReference()) {
            return getRef().getName();
        }
        String name = getURL().getFile();
        return name.isEmpty() ? name : name.substring(1);
    }

    
Return this URLResource formatted as a String.

Returns:a String representation of this URLResource.
/**
     * Return this URLResource formatted as a String.
     * @return a String representation of this URLResource.
     */
    public synchronized String toString() {
        return isReference()
            ? getRef().toString() : String.valueOf(getURL());
    }

    
Find out whether the URL exists .

Returns:true if this resource exists.
/**
     * Find out whether the URL exists .
     * @return true if this resource exists.
     */
    public synchronized boolean isExists() {
        if (isReference()) {
            return getRef().isExists();
        }
        return isExists(false);
    }

    
Find out whether the URL exists, and close the connection
opened to the URL if closeConnection is true.
Note that this method does ensure that if:
- the resource exists (if it returns true)
- and if the current object is not a reference
(isReference() returns false)
- and if it was called with closeConnection to false,
then the connection to the URL (stored in the conn
private field) will be opened, and require to be closed
by the caller.

Params:
  • closeConnection – true if the connection should be closed
after the call, false if it should stay open.
Returns:true if this resource exists.
/**
     * Find out whether the URL exists, and close the connection
     * opened to the URL if closeConnection is true.
     *
     * Note that this method does ensure that if:
     * - the resource exists (if it returns true)
     * - and if the current object is not a reference
     * (isReference() returns false)
     * - and if it was called with closeConnection to false,
     *
     * then the connection to the URL (stored in the conn
     * private field) will be opened, and require to be closed
     * by the caller.
     *
     * @param closeConnection true if the connection should be closed
     * after the call, false if it should stay open.
     * @return true if this resource exists.
     */
    private synchronized boolean isExists(boolean closeConnection) {
        if (getURL() == null) {
            return false;
        }
        try {
            connect(Project.MSG_VERBOSE);
            if (conn instanceof HttpURLConnection) {
                int sc = ((HttpURLConnection) conn).getResponseCode();
                // treating inaccessible resources as non-existent
                return sc < 400;
            } else if (url.getProtocol().startsWith("ftp")) {
                closeConnection = true;
                InputStream in = null;
                try {
                    in = conn.getInputStream();
                } finally {
                    FileUtils.close(in);
                }
            }
            return true;
        } catch (IOException e) {
            return false;
        } finally {
            if (closeConnection) {
                close();
            }
        }
    }


    
Tells the modification time in milliseconds since 01.01.1970 .

Returns:0 if the resource does not exist to mirror the behavior of File.
/**
     * Tells the modification time in milliseconds since 01.01.1970 .
     *
     * @return 0 if the resource does not exist to mirror the behavior
     * of {@link java.io.File File}.
     */
    public synchronized long getLastModified() {
        if (isReference()) {
            return getRef().getLastModified();
        }
        if (!isExists(false)) {
            return UNKNOWN_DATETIME;
        }
        return withConnection(c -> conn.getLastModified(), UNKNOWN_DATETIME);
    }

    
Tells if the resource is a directory.

Returns:boolean whether the resource is a directory.
/**
     * Tells if the resource is a directory.
     * @return boolean whether the resource is a directory.
     */
    public synchronized boolean isDirectory() {
        return isReference()
            ? getRef().isDirectory()
            : getName().endsWith("/");
    }

    
Get the size of this Resource.

Returns:the size, as a long, 0 if the Resource does not exist (for
        compatibility with java.io.File), or UNKNOWN_SIZE if not known.
/**
     * Get the size of this Resource.
     * @return the size, as a long, 0 if the Resource does not exist (for
     *         compatibility with java.io.File), or UNKNOWN_SIZE if not known.
     */
    public synchronized long getSize() {
        if (isReference()) {
            return getRef().getSize();
        }
        if (!isExists(false)) {
            return 0L;
        }
        return withConnection(c -> conn.getContentLength(), UNKNOWN_SIZE);
    }

    
Test whether an Object equals this URLResource.

Params:
  • another – the other Object to compare.
Returns:true if the specified Object is equal to this Resource.
/**
     * Test whether an Object equals this URLResource.
     * @param another the other Object to compare.
     * @return true if the specified Object is equal to this Resource.
     */
    public synchronized boolean equals(Object another) {
        if (this == another) {
            return true;
        }
        if (isReference()) {
            return getRef().equals(another);
        }
        if (another == null || another.getClass() != getClass()) {
            return false;
        }
        URLResource other = (URLResource) another;
        return getURL() == null
            ? other.getURL() == null
            : getURL().equals(other.getURL());
    }

    
Get the hash code for this Resource.

Returns:hash code as int.
/**
     * Get the hash code for this Resource.
     * @return hash code as int.
     */
    public synchronized int hashCode() {
        if (isReference()) {
            return getRef().hashCode();
        }
        return MAGIC * ((getURL() == null) ? NULL_URL : getURL().hashCode());
    }

    
Get an InputStream for the Resource.

Throws:
Returns:an InputStream containing this Resource's content.
/**
     * Get an InputStream for the Resource.
     * @return an InputStream containing this Resource's content.
     * @throws IOException if unable to provide the content of this
     *         Resource as a stream.
     * @throws UnsupportedOperationException if InputStreams are not
     *         supported for this Resource type.
     */
    public synchronized InputStream getInputStream() throws IOException {
        if (isReference()) {
            return getRef().getInputStream();
        }
        connect();
        try {
            return conn.getInputStream();
        } finally {
            conn = null;
        }
    }

    
Get an OutputStream for the Resource.

Throws:
Returns:an OutputStream to which content can be written.
/**
     * Get an OutputStream for the Resource.
     * @return an OutputStream to which content can be written.
     * @throws IOException if unable to provide the content of this
     *         Resource as a stream.
     * @throws UnsupportedOperationException if OutputStreams are not
     *         supported for this Resource type.
     * @throws IOException if the URL cannot be opened.
     */
    public synchronized OutputStream getOutputStream() throws IOException {
        if (isReference()) {
            return getRef().getOutputStream();
        }
        connect();
        try {
            return conn.getOutputStream();
        } finally {
            conn = null;
        }
    }

    
Ensure that we have a connection.

Throws:
  • IOException – if the connection cannot be established.
/**
     * Ensure that we have a connection.
     * @throws IOException if the connection cannot be established.
     */
    protected void connect() throws IOException {
        connect(Project.MSG_ERR);
    }

    
Ensure that we have a connection.

Params:
  • logLevel – severity to use when logging connection errors.
Should be one of the MSG_ constants in Project.
Throws:
  • IOException – if the connection cannot be established.
Since:Ant 1.8.2
/**
     * Ensure that we have a connection.
     * @param logLevel severity to use when logging connection errors.
     * Should be one of the <code>MSG_</code> constants in {@link
     * Project Project}.
     * @throws IOException if the connection cannot be established.
     * @since Ant 1.8.2
     */
    protected synchronized void connect(int logLevel) throws IOException {
        URL u = getURL();
        if (u == null) {
            throw new BuildException("URL not set");
        }
        if (conn == null) {
            try {
                conn = u.openConnection();
                conn.connect();
            } catch (IOException e) {
                log(e.toString(), logLevel);
                conn = null;
                throw e;
            }
        }
    }

    @Override
    protected URLResource getRef() {
        return getCheckedRef(URLResource.class);
    }

    
Closes the URL connection if:
- it is opened (i.e. the field conn is not null)
- this type of URLConnection supports some sort of close mechanism
This method ensures the field conn will be null after the call.

/**
     * Closes the URL connection if:
     * - it is opened (i.e. the field conn is not null)
     * - this type of URLConnection supports some sort of close mechanism
     *
     * This method ensures the field conn will be null after the call.
     *
     */
    private synchronized void close() {
        try {
            FileUtils.close(conn);
        } finally {
            conn = null;
        }
    }

    private static URL newURL(String u) {
        try {
            return new URL(u);
        } catch (MalformedURLException e) {
            throw new BuildException(e);
        }
    }

    private interface ConnectionUser {
        long useConnection(URLConnection c);
    }

    private long withConnection(ConnectionUser u, long defaultValue) {
        try {
            if (conn != null) {
                return u.useConnection(conn);
            } else {
                try {
                    connect();
                    return u.useConnection(conn);
                } finally {
                    close();
                }
            }
        } catch (IOException ex) {
            return defaultValue;
        }
    }
}