path: root/src/lombok/installer/EclipseFinder.java

/*
 * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package lombok.installer;

import static java.util.Arrays.asList;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import lombok.Lombok;
import lombok.core.Version;

/** Utility class for doing various OS-specific operations related to finding Eclipse installations. */
class EclipseFinder {
	private EclipseFinder() {
		//Prevent instantiation.
	}
	
	/**
	 * Returns a File object pointing to our own jar file. Will obviously fail if the installer was started via
	 * a jar that wasn't accessed via the file-system, or if its started via e.g. unpacking the jar.
	 */
	static File findOurJar() {
		try {
			URI uri = EclipseFinder.class.getResource("/" + EclipseFinder.class.getName().replace('.', '/') + ".class").toURI();
			Pattern p = Pattern.compile("^jar:file:([^\\!]+)\\!.*\\.class$");
			Matcher m = p.matcher(uri.toString());
			if ( !m.matches() ) return new File("lombok.jar");
			String rawUri = m.group(1);
			return new File(URLDecoder.decode(rawUri, Charset.defaultCharset().name()));
		} catch ( Exception e ) {
			throw Lombok.sneakyThrow(e);
		}
	}
	
	private static final AtomicBoolean windowsDriveInfoLibLoaded = new AtomicBoolean(false);
	private static void loadWindowsDriveInfoLib() throws IOException {
		if ( !windowsDriveInfoLibLoaded.compareAndSet(false, true) ) return;
		
		final String prefix = "lombok-" + Version.getVersion() + "-";
		
		File temp = File.createTempFile("lombok", ".mark");
		File dll1 = new File(temp.getParentFile(), prefix + "WindowsDriveInfo-i386.dll");
		File dll2 = new File(temp.getParentFile(), prefix + "WindowsDriveInfo-x86_64.dll");
		temp.delete();
		dll1.deleteOnExit();
		dll2.deleteOnExit();
		try {
			if ( unpackDLL("WindowsDriveInfo-i386.dll", dll1) ) {
				System.load(dll1.getAbsolutePath());
				return;
			}
		} catch ( Throwable ignore ) {}
		
		try {
			if ( unpackDLL("WindowsDriveInfo-x86_64.dll", dll2) ) {
				System.load(dll2.getAbsolutePath());
			}
		} catch ( Throwable ignore ) {}
	}
	
	private static boolean unpackDLL(String dllName, File target) throws IOException {
		InputStream in = EclipseFinder.class.getResourceAsStream(dllName);
		try {
			try {
				FileOutputStream out = new FileOutputStream(target);
				try {
					byte[] b = new byte[32000];
					while ( true ) {
						int r = in.read(b);
						if ( r == -1 ) break;
						out.write(b, 0, r);
					}
				} finally {
					out.close();
				}
			} catch ( IOException e ) {
				//Fall through - if there is a file named lombok-WindowsDriveInfo-arch.dll, we'll try it.
				return target.exists() && target.canRead();
			}
		} finally {
			in.close();
		}
		
		return true;
	}
	
	/**
	 * Returns all drive letters on windows, regardless of what kind of drive is represented.
	 * 
	 * @return A List of drive letters, such as ["A", "C", "D", "X"].
	 */
	static List<String> getDrivesOnWindows() throws Throwable {
		loadWindowsDriveInfoLib();
		
		List<String> drives = new ArrayList<String>();
		
		WindowsDriveInfo info = new WindowsDriveInfo();
		for ( String drive : info.getLogicalDrives() ) {
			if ( info.isFixedDisk(drive) ) drives.add(drive);
		}
		
		return drives;
	}

	/**
	 * Returns a list of paths of Eclipse installations.
	 * Eclipse installations are found by checking for the existence of 'eclipse.exe' in the following locations:
	 * 
	 * X:\*Program Files*\*Eclipse*
	 * X:\*Eclipse*
	 * 
	 * Where 'X' is tried for all local disk drives, unless there's a problem calling fsutil, in which case only
	 * C: is tried.
	 * 
	 * @return A List of directories that contain 'eclipse.exe'.
	 */
	static List<String> findEclipseOnWindows() {
		List<String> eclipses = new ArrayList<String>();
		List<String> driveLetters = asList("C");
		try {
			driveLetters = getDrivesOnWindows();
		} catch ( Throwable ignore ) {
			ignore.printStackTrace();
		}
		
		for ( String letter : driveLetters ) {
			File f = new File(letter + ":\\");
			for ( File dir : f.listFiles() ) {
				if ( !dir.isDirectory() ) continue;
				if ( dir.getName().toLowerCase().contains("eclipse") ) {
					String eclipseLocation = findEclipseOnWindows1(dir);
					if ( eclipseLocation != null ) eclipses.add(eclipseLocation);
				}
				if ( dir.getName().toLowerCase().contains("program files") ) {
					for ( File dir2 : dir.listFiles() ) {
						if ( !dir2.isDirectory() ) continue;
						if ( dir.getName().toLowerCase().contains("eclipse") ) {
							String eclipseLocation = findEclipseOnWindows1(dir);
							if ( eclipseLocation != null ) eclipses.add(eclipseLocation);
						}
					}
				}
			}
		}
		
		return eclipses;
	}
	
	/** Checks if the provided directory contains 'eclipse.exe', and if so, returns the directory, otherwise null. */
	private static String findEclipseOnWindows1(File dir) {
		if ( new File(dir, "eclipse.exe").isFile() ) return dir.getAbsolutePath();
		return null;
	}
	
	/**
	 * Calls the OS-dependent 'find Eclipse' routine. If the local OS doesn't have a routine written for it,
	 * null is returned.
	 * 
	 * @return List of directories that contain the Eclipse executable.
	 */
	static List<String> findEclipses() {
		switch ( getOS() ) {
		case WINDOWS:
			return findEclipseOnWindows();
		case MAC_OS_X:
			return findEclipseOnMac();
		default:
		case UNIX:
			return null;
		}
	}
	
	static enum OS {
		MAC_OS_X, WINDOWS, UNIX;
	}
	
	static OS getOS() {
		String prop = System.getProperty("os.name", "").toLowerCase();
		if ( prop.matches("^.*\\bmac\\b.*$") ) return OS.MAC_OS_X;
		if ( prop.matches("^.*\\bdarwin\\b.*$") ) return OS.MAC_OS_X;
		if ( prop.matches("^.*\\bwin(dows)\\b.*$") ) return OS.WINDOWS;
		
		return OS.UNIX;
	}
	
	/**
	 * Returns the proper name of the executable for the local OS.
	 * 
	 * @return 'Eclipse.app' on OS X, 'eclipse.exe' on Windows, and 'eclipse' on other OSes.
	 */
	static String getEclipseExecutableName() {
		switch ( getOS() ) {
		case WINDOWS:
			return "eclipse.exe";
		case MAC_OS_X:
			return "Eclipse.app";
		default:
		case UNIX:
			return "eclipse";
		}
	}
	
	/**
	 * Scans /Applications for any folder named 'Eclipse'
	 */
	static List<String> findEclipseOnMac() {
		List<String> eclipses = new ArrayList<String>();
		for ( File dir : new File("/Applications").listFiles() ) {
			if ( !dir.isDirectory() ) continue;
			if ( dir.getName().toLowerCase().equals("eclipse.app") ) {
				//This would be kind of an unorthodox Eclipse installation, but if Eclipse ever
				//moves to this more maclike installation concept, our installer can still handle it.
				eclipses.add("/Applications");
			}
			if ( dir.getName().toLowerCase().contains("eclipse") ) {
				if ( new File(dir, "Eclipse.app").exists() ) eclipses.add(dir.toString());
			}
		}
		return eclipses;
	}
}