path: root/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveURIConverterImpl.java

/*******************************************************************************
 * Copyright (c) 2001, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.j2ee.commonarchivecore.internal.helpers;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import com.ibm.icu.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.impl.URIConverterImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategy;
import org.eclipse.jst.jee.archive.internal.ArchiveUtil;


/**
 * Helper class used for loading of mof resources contained within an archive; knows how to retrieve
 * an input stream for a given uri
 */
public class ArchiveURIConverterImpl extends URIConverterImpl {
	protected static final String fileProtocol = "file"; //$NON-NLS-1$
	protected static final String platformProtocol = "platform"; //$NON-NLS-1$
	private String inFilepath, outFilepath;

	public ArchiveURIConverterImpl(org.eclipse.jst.j2ee.commonarchivecore.internal.Archive anArchive, String resourcesPath) {
		setArchive(anArchive);
		this.resourcesPath = resourcesPath;
		setInputFilepath(resourcesPath);
		String outpath = resourcesPath;
		if (outpath == null) {
			LoadStrategy l = anArchive.getLoadStrategy();
			if (l != null && l.isDirectory()) {
				try {
					outpath = l.getAbsolutePath();
				} catch (FileNotFoundException ignore) {
					//Ignore
				}
			}
		}
		setOutputFilepath(outpath);
	}

	/** The archive from which resources will be loaded */
	protected org.eclipse.jst.j2ee.commonarchivecore.internal.Archive archive;
	protected String resourcesPath;

	public org.eclipse.jst.j2ee.commonarchivecore.internal.Archive getArchive() {
		return archive;
	}

	@Override
	public InputStream createInputStream(URI uri) throws IOException {
		InputStream in = null;
		if (resourcesPath != null)
			in = makeInputStream(uri);
		if (in != null)
			return in;
		return getArchive().getInputStream(uri.toString());
	}

	public void setArchive(org.eclipse.jst.j2ee.commonarchivecore.internal.Archive newArchive) {
		archive = newArchive;
	}

	/**
	 * Gets the resourcesPath.
	 * 
	 * @return Returns a String
	 */
	public String getResourcesPath() {
		return resourcesPath;
	}

	/**
	 * Sets the resourcesPath.
	 * 
	 * @param resourcesPath
	 *            The resourcesPath to set
	 */
	public void setResourcesPath(String resourcesPath) {
		this.resourcesPath = resourcesPath;
		setInputFilepath(resourcesPath);
		setOutputFilepath(resourcesPath);
	}

	@Override
	public URI normalize(URI uri) {
		return ((URIConverterImpl.URIMap)getURIMap()).getURI(uri);
	}

	/**
	 * The input file path consists of a string of directories or zip files separated by semi-colons
	 * that are searched when an input stream is constructed.
	 * 
	 * @return The file path
	 */
	public String getInputFilepath() {
		return inFilepath;
	}

	/**
	 * @param filepath
	 *            The file path
	 */
	public void setInputFilepath(String filepath) {
		inFilepath = filepath;
	}

	/**
	 * @return The output file path
	 */
	public String getOutputFilepath() {
		return outFilepath;
	}

	/**
	 * The output file path is the path name of a directory to prepend to relative file path names
	 * when an output stream is constructed.
	 * 
	 * @param filepath
	 *            The output file path
	 */
	public void setOutputFilepath(String filepath) {
		outFilepath = filepath;
	}

	/**
	 * Convert the URI to an input stream.
	 * 
	 * @param uri
	 *            The uri
	 */
	public InputStream makeInputStream(URI uri) throws IOException {
		URI converted = uri;

		if ((fileProtocol.equals(converted.scheme()) || converted.scheme() == null) && inFilepath != null) {
			return searchFilePath(converted.toString());
		}
		URL url = createURL(converted.toString());
		URLConnection urlConnection = url.openConnection();
		return urlConnection.getInputStream();
	}

	/**
	 * Search the file path if the file portion of the URL is not absolute (does not begin with "/";
	 * otherwise, attempt to create an input stream for the file.
	 */
	protected InputStream searchFilePath(String filename) throws IOException {
		File file = new File(filename);
		if (file.isAbsolute())
			return new FileInputStream(file);
		StringTokenizer st = new StringTokenizer(inFilepath, ";"); //$NON-NLS-1$
		while (st.hasMoreTokens()) {
			String f = st.nextToken();
			ZipFile zf = null;
			try {
				zf = ArchiveUtil.newZipFile(f);
			} catch (Exception e) {
				//Ignore
			}
			InputStream in = null;
			if (zf != null) {
				in = searchZipFile(zf, filename);
				if (in == null)
					try {
						zf.close();
					} catch (Exception e) {
						//Ignore
					}
			} else {
				in = searchDirectory(f, filename);
			}
			if (in != null)
				return in;
		}
		return null;
	}

	/**
	 * This method determines whether the file with the relative path name of filename exists in the
	 * given directory. If not, it returns null; otherwise, it opens the file up and returns the
	 * input source.
	 * 
	 * @param dir
	 *            java.lang.String
	 * @return java.io.InputSource
	 */
	protected InputStream searchDirectory(String dir, String filename) throws IOException {
		if (dir.equals(".")) //$NON-NLS-1$
			dir = System.getProperty("user.dir"); //$NON-NLS-1$
		File f = new File(dir + System.getProperty("file.separator") + filename.replace('/', File.separatorChar)); //$NON-NLS-1$
		if (!f.exists())
			return null;
		return new FileInputStream(f);
	}

	/**
	 * This method determines whether there is a ZipEntry whose name is filename in the given
	 * ZipFile. If not, it returns null; otherwise, it returns an input source to read from the
	 * ZipEntry.
	 * 
	 * @param zip
	 *            java.util.zip.ZipFile
	 * @return java.io.InputSource
	 */
	protected InputStream searchZipFile(ZipFile zip, String filename) throws IOException {
		ZipEntry entry = zip.getEntry(filename);
		if (entry == null)
			return null;
		return zip.getInputStream(entry);
	}

	/**
	 * Make a URL from the uri; if the attempt fails, attempt to append "file:" to the URI; if the
	 * attempt still fails, attempt to replace the protocol with the file protocol.
	 * 
	 * @param uri
	 *            The string uri
	 */
	public URL createURL(String uri) throws MalformedURLException {
		MalformedURLException m = null;
		if (uri == null)
			return null;
		URL url = null;
		try {
			url = new URL(uri);
		} catch (Exception e) {
			m = (MalformedURLException) e;
		}
		if (url != null)
			return url;
		// Either treat the URI as a filepath (if there are no : or
		// a : in position 1) or replace the given protocol with the
		// file protocol.
		int index = uri.indexOf(":"); //$NON-NLS-1$
		if (index == -1 || index == 1)
			uri = fileProtocol + ":" + uri; //$NON-NLS-1$
		else if (index > 0)
			uri = fileProtocol + ":" + uri.substring(index + 1); //$NON-NLS-1$
		try {
			url = new URL(uri);
		} catch (Exception e) {
			//Ignore
		}
		if (url != null)
			return url;
		else if(m != null)
			throw m;
		else 
			throw new MalformedURLException();
	}

	/**
	 * Convert the URI to an output stream.
	 * 
	 * @param uri
	 *            The uri
	 */
	@Override
	public OutputStream createOutputStream(URI uri) throws IOException {
		URI converted = uri;
		if (platformProtocol.equals(converted.scheme())) {
			URL resolvedURL = resolvePlatform(new URL(converted.toString()));
			if (resolvedURL != null) {
				converted = URI.createFileURI(resolvedURL.getFile());
			}
		}
		if (fileProtocol.equals(converted.scheme()) || converted.scheme() == null) {
			return openFileOutputStream(converted);
		}
		URL url = createURL(converted.toString());
		URLConnection urlConnection = url.openConnection();
		urlConnection.setDoOutput(true);
		return urlConnection.getOutputStream();
	}

	protected URL resolvePlatform(URL url) throws IOException {
		// let WorkbenchURIConverter implement this one.
		return null;
	}

	/**
	 * Open a file output stream for the given uri (the uri has file protocol). If an output file
	 * path is specified and the file name is relative, prepend the output file path to the file
	 * name. Make the directories that contain the file if they do not exist.
	 */
	protected OutputStream openFileOutputStream(URI uri) throws IOException {
		File file = new File(uri.toFileString());
		if (!file.isAbsolute() && outFilepath != null) {
			file = new File(outFilepath + File.separator + uri.toFileString());
		}
		String parent = file.getParent();
		if (parent != null) {
			new File(parent).mkdirs();
		}
		OutputStream outputStream = new FileOutputStream(file);
		return outputStream;
	}
}