Java tutorial
/* * Copyright 2013 Amazon Technologies, Inc. * * 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://aws.amazon.com/apache2.0 * * This file 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.amazonaws.eclipse.dynamodb.testtool; import java.io.BufferedReader; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.util.Collection; import org.apache.commons.io.FileUtils; import org.apache.commons.io.filefilter.AbstractFileFilter; import org.apache.commons.io.filefilter.IOFileFilter; import org.apache.commons.io.filefilter.TrueFileFilter; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.jdt.launching.IVMInstall; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.console.ConsolePlugin; import org.eclipse.ui.console.IConsole; import org.eclipse.ui.console.IConsoleConstants; import org.eclipse.ui.console.IConsoleManager; import org.eclipse.ui.console.IConsoleView; import org.eclipse.ui.console.MessageConsole; import org.eclipse.ui.console.MessageConsoleStream; import com.amazonaws.eclipse.core.AwsToolkitCore; import com.amazonaws.eclipse.dynamodb.DynamoDBPlugin; /** * A DynamoDB Local Test Tool process. */ public class TestToolProcess { private final IVMInstall jre; private final File installDirectory; private final int port; private final Thread shutdownHook = new Thread() { @Override public void run() { TestToolProcess.this.stopProcess(); } }; private Process process; /** * Create a new {@code TestToolProcess}. * * @param jre the JRE to use to run DynamoDBLocal * @param installDirectory the root install directory for DynamoDBLocal * @param port the TCP port to bind to */ public TestToolProcess(final IVMInstall jre, final File installDirectory, final int port) { this.jre = jre; this.installDirectory = installDirectory; this.port = port; } /** * @return the port that this DynamoDBLocal process is listening on */ public int getPort() { return port; } /** * Start the DynamoDBLocal process. * * @param onExitAction optional action to be executed when the process * exits * @throws IOException if starting the process fails */ public synchronized void start(final Runnable onExitAction) throws IOException { if (process != null) { throw new IllegalStateException("Already started!"); } ProcessBuilder builder = new ProcessBuilder(); builder.directory(installDirectory); builder.command(jre.getInstallLocation().getAbsolutePath().concat("/bin/java"), "-Djava.library.path=".concat(findLibraryDirectory().getAbsolutePath()), "-jar", "DynamoDBLocal.jar", "--port", Integer.toString(port)); // Drop STDERR into STDOUT so we can handle them together. builder.redirectErrorStream(true); // Register a shutdown hook to kill DynamoDBLocal if Eclipse exits. Runtime.getRuntime().addShutdownHook(shutdownHook); // Start the DynamoDBLocal process. process = builder.start(); // Start a background thread to read any output from DynamoDBLocal // and dump it to an IConsole. new ConsoleOutputLogger(process.getInputStream(), onExitAction).start(); } /** * Searches within the install directory for the native libraries required * by DyanmoDB Local (i.e. SQLite) and returns the directory containing the * native libraries. * * @return The directory within the install directory where native libraries * were found; otherwise, if no native libraries are found, the * install directory is returned. */ private File findLibraryDirectory() { // Mac and Linux libraries start with "libsqlite4java-" so // use that pattern to identify the library directory IOFileFilter fileFilter = new AbstractFileFilter() { public boolean accept(File dir, String name) { return name.startsWith("libsqlite4java-"); } }; Collection<File> files = FileUtils.listFiles(installDirectory, fileFilter, TrueFileFilter.INSTANCE); // Log a warning if we can't identify the library directory, // and then just try to use the install directory if (files == null || files.isEmpty()) { Status status = new Status(IStatus.WARNING, DynamoDBPlugin.PLUGIN_ID, "Unable to find DynamoDB Local native libraries in " + installDirectory); AwsToolkitCore.getDefault().getLog().log(status); return installDirectory; } return files.iterator().next().getParentFile(); } /** * Stop the DynamoDBLocal process and deregister the shutdown hook. */ public synchronized void stop() { stopProcess(); Runtime.getRuntime().removeShutdownHook(shutdownHook); } /** * Internal helper method to actually stop the DynamoDBLocal process. */ private void stopProcess() { if (process != null) { process.destroy(); process = null; } } /** * A background thread that reads output from the DynamoDBLocal process * and pumps it to a console window. */ private static class ConsoleOutputLogger extends Thread { private final BufferedReader input; private final Runnable onExitAction; /** * Create a new logger. * * @param stream the input stream to read from * @param onExitaction an optional action to be run when the process * exits */ public ConsoleOutputLogger(final InputStream stream, final Runnable onExitAction) { this.input = new BufferedReader(new InputStreamReader(stream)); this.onExitAction = onExitAction; super.setDaemon(true); super.setName("DynamoDBLocal Console Output Logger"); } @Override public void run() { MessageConsole console = findConsole(); displayConsole(console); MessageConsoleStream stream = console.newMessageStream(); try { while (true) { String line = input.readLine(); if (line == null) { stream.println("*** DynamoDB Local Exited ***"); break; } stream.println(line); } } catch (IOException exception) { stream.println("Exception reading the output of " + "DynamoDB Local: " + exception.toString()); } finally { try { input.close(); } catch (IOException exception) { exception.printStackTrace(); } try { stream.close(); } catch (IOException exception) { exception.printStackTrace(); } if (onExitAction != null) { onExitAction.run(); } } } /** * Find or create a new console window for DynamoDBLocal's output. * * @return the console to log output to */ private MessageConsole findConsole() { ConsolePlugin plugin = ConsolePlugin.getDefault(); IConsoleManager manager = plugin.getConsoleManager(); IConsole[] existing = manager.getConsoles(); for (int i = 0; i < existing.length; ++i) { if (existing[i].getName().equals("DynamoDB Local")) { return (MessageConsole) existing[i]; } } MessageConsole console = new MessageConsole("DynamoDB Local", null); manager.addConsoles(new IConsole[] { console }); return console; } /** * Display the given console if it's not already visible. * * @param console the console to display */ private void displayConsole(final IConsole console) { Display.getDefault().asyncExec(new Runnable() { public void run() { IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { IConsoleView view = (IConsoleView) page.showView(IConsoleConstants.ID_CONSOLE_VIEW); view.display(console); } catch (PartInitException exception) { // Is there something more intelligent we should be // doing with this? exception.printStackTrace(); } } }); } } }