Java tutorial
/** * Copyright 2011-2017 Asakusa Framework Team. * * 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 com.asakusafw.runtime.windows; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.text.MessageFormat; import java.util.UUID; import java.util.concurrent.atomic.AtomicReference; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.util.Shell; import org.xerial.snappy.OSInfo; import com.asakusafw.runtime.io.util.TemporaryFileInstaller; /** * Installs {@code winutils.exe} into the current environment. * @since 0.9.0 */ public final class WinUtilsInstaller { static final Log LOG = LogFactory.getLog(WinUtilsInstaller.class); private static final Field WINUTILS_PATH; static { Field f = null; if (Shell.WINDOWS) { try { // only Hadoop 2.x has 'Shell.WINUTILS:String' f = Shell.class.getField("WINUTILS"); //$NON-NLS-1$ f.setAccessible(true); if (f.getType() != String.class) { throw new IllegalStateException(MessageFormat .format("incompatible Shell.WINUTILS return type: {0}", f.getType().getName())); } // Hack: we try to remove final flag from 'Shell.WINUTILS' Field modifiers = Field.class.getDeclaredField("modifiers"); //$NON-NLS-1$ modifiers.setAccessible(true); modifiers.setInt(f, f.getModifiers() & ~Modifier.FINAL); } catch (Exception e) { LOG.debug("current Hadoop version does not support winutils.exe", e); //$NON-NLS-1$ } } WINUTILS_PATH = f; } private static final String ARCH_32 = "x86"; //$NON-NLS-1$ private static final String ARCH_64 = "x86_64"; //$NON-NLS-1$ private static final String SOURCE = getArchitecture() + "/winutils.exe"; //$NON-NLS-1$ private static final String TARGET_PREFIX = "winutils-" + getUserHash(); //$NON-NLS-1$ private static final String TARGET_SUFFIX = ".exe"; //$NON-NLS-1$ private static final AtomicReference<TemporaryFileInstaller> CACHE = new AtomicReference<>(); private WinUtilsInstaller() { return; } /** * Returns whether the current environment requires {@code winutils.exe} or not. * @return {@code true} if the current environment requires {@code winutils.exe}, otherwise {@code false} */ public static boolean isTarget() { return WINUTILS_PATH != null; } /** * Returns whether the current environment already has {@code winutils.exe} or not. * @return {@code true} if the current environment already has {@code winutils.exe}, otherwise {@code false} */ public static boolean isAlreadyInstalled() { if (isTarget() == false) { return false; } try { String path = (String) WINUTILS_PATH.get(null); return path != null && new File(path).canExecute(); } catch (Exception e) { LOG.debug("exception occurred while checking winutils.exe", e); //$NON-NLS-1$ return false; } } /** * Installs {@code winutils.exe} into the target directory. * @param directory the target directory * @return installed location (never null) * @throws IOException if error occurred while installing */ public static File put(File directory) throws IOException { TemporaryFileInstaller installer = prepare(); assert installer != null; // install into the default location File file = new File(directory, TARGET_PREFIX + TARGET_SUFFIX); try { LOG.info(MessageFormat.format("installing winutils.exe into default location: {0}", //$NON-NLS-1$ file)); installer.install(file, true); return file; } catch (IOException e) { LOG.debug(MessageFormat.format("failed to install winutils into the default location: {0}", file), e); } // install into a temporary location File temp = null; boolean success = false; try { temp = File.createTempFile(TARGET_PREFIX + '-', TARGET_SUFFIX, directory); LOG.info(MessageFormat.format("installing winutils.exe into temporary location: {0}", temp)); installer.install(temp, false); temp.deleteOnExit(); success = true; return temp; } catch (IOException e) { LOG.debug(MessageFormat.format("failed to install winutils into a temporary location: {0}", //$NON-NLS-1$ temp), e); } finally { if (success == false) { if (temp != null && temp.delete() == false) { LOG.warn(MessageFormat.format("failed to delete a temporary file: {0}", //$NON-NLS-1$ temp)); } } } throw new IOException(MessageFormat.format("error occurred while installing winutils: {0}", //$NON-NLS-1$ file)); } /** * Registers a {@code winutils.exe} file. * @param executable the executable file path, or {@code null} to remove it */ public static void register(File executable) { try { WINUTILS_PATH.set(null, executable == null ? null : executable.getAbsolutePath()); } catch (IllegalAccessException e) { throw new IllegalStateException(e); } } private static TemporaryFileInstaller prepare() throws IOException { TemporaryFileInstaller installer = CACHE.get(); if (installer != null) { return installer; } try (InputStream input = WinUtilsInstaller.class.getResourceAsStream(SOURCE)) { if (input == null) { throw new IllegalStateException(MessageFormat.format("missing {0} in the classpath", //$NON-NLS-1$ SOURCE)); } installer = TemporaryFileInstaller.newInstance(input, true); CACHE.compareAndSet(null, installer); } return CACHE.get(); } private static String getArchitecture() { String name = OSInfo.getArchName(); if (name.equals(ARCH_32) || name.equals(ARCH_64)) { return name; } return ARCH_64; } private static String getUserHash() { String base = System.getProperty("user.name", UUID.randomUUID().toString()); //$NON-NLS-1$ StringBuilder buf = new StringBuilder(); for (char c : base.toCharArray()) { if ('0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '_' || c == '-') { buf.append(c); } } if (buf.length() < 4) { buf.append('-'); buf.append(Integer.toHexString(base.hashCode())); } return buf.toString(); } }