Java tutorial
// Copyright 2017 JanusGraph Authors // // 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 org.janusgraph.pkgtest; import static org.junit.Assert.assertEquals; import java.io.*; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.PrintStream; import java.io.Writer; import java.util.Collections; import java.util.Map; import java.util.Properties; import org.apache.commons.io.FileUtils; import org.apache.velocity.Template; import org.apache.velocity.VelocityContext; import org.apache.velocity.app.Velocity; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableMap; import org.janusgraph.core.JanusGraphFactory; public abstract class AbstractJanusGraphAssemblyIT { protected static final String BUILD_DIR; protected static final String EXPECT_DIR; protected static final String ZIPFILE_PATH; protected static final String ZIPFILE_EXTRACTED; static { Properties props; try { props = new Properties(); java.io.FileReader fr = new FileReader( Joiner.on(File.separator).join(new String[] { "target", "test-classes", "target.properties" })); ; props.load(fr); fr.close(); } catch (IOException e) { throw new AssertionError(e); } BUILD_DIR = props.getProperty("build.dir"); EXPECT_DIR = props.getProperty("expect.dir"); ZIPFILE_PATH = props.getProperty("zipfile.path"); ZIPFILE_EXTRACTED = ZIPFILE_PATH.substring(0, ZIPFILE_PATH.length() - 4); Properties p = new Properties(); p.put("file.resource.loader.path", EXPECT_DIR); Velocity.init(p); } protected void testSimpleGremlinSession(String graphConfig, String graphToString) throws Exception { unzipAndRunExpect("single-vertex.expect.vm", graphConfig, graphToString); } protected void testGettingStartedGremlinSession(String graphConfig, String graphToString) throws Exception { unzipAndRunExpect("getting-started.expect.vm", graphConfig, graphToString); } protected void unzipAndRunExpect(String expectTemplateName, Map<String, String> contextVars) throws Exception { FileUtils.deleteQuietly(new File(ZIPFILE_EXTRACTED)); unzip(BUILD_DIR, ZIPFILE_PATH); parseTemplateAndRunExpect(expectTemplateName, contextVars); } protected void parseTemplateAndRunExpect(String expectTemplateName, Map<String, String> contextVars) throws IOException, InterruptedException { VelocityContext context = new VelocityContext(); for (Map.Entry<String, String> ent : contextVars.entrySet()) { context.put(ent.getKey(), ent.getValue()); } Template template = Velocity.getTemplate(expectTemplateName); String inputPath = EXPECT_DIR + File.separator + expectTemplateName; String outputPath = inputPath.substring(0, inputPath.length() - 3); Writer output = new FileWriter(outputPath); template.merge(context, output); output.close(); expect(ZIPFILE_EXTRACTED, outputPath); } protected void unzipAndRunExpect(String expectTemplateName) throws Exception { unzipAndRunExpect(expectTemplateName, Collections.<String, String>emptyMap()); } protected void unzipAndRunExpect(String expectTemplateName, String graphConfig, String graphToString) throws Exception { unzipAndRunExpect(expectTemplateName, ImmutableMap.of("graphConfig", graphConfig, "graphToString", graphToString)); } private static void expect(String dir, String expectScript) throws IOException, InterruptedException { command(new File(dir), "expect", expectScript); } protected static void unzip(String dir, String zipfile) throws IOException, InterruptedException { command(new File(dir), "unzip", "-q", zipfile); } protected static void command(File dir, String... command) throws IOException, InterruptedException { ProcessBuilder pb = new ProcessBuilder(command); pb.directory(dir); // pb.redirectInput(Redirect.PIPE); /* * Using Redirect.INHERIT with expect breaks maven-failsafe-plugin when * failsafe is configured to fork. The parent and child normally * communicate over stdout/stderr in fork mode. But after executing * expect, this failsafe communication starts appearing on the terminal. * The parent never sees it and assumes no tests ran. expect is probably * doing something nasty to its file descriptors and neglecting to clean * up after itself. Invoking unzip does not break failsafe+forks in this * way. So expect must be doing something unusual with its file * descriptors. * * Redirect.INHERIT works fine if failsafe is configured to never fork. */ // pb.redirectOutput(Redirect.INHERIT); // pb.redirectError(Redirect.INHERIT); // pb.redirectOutput(Redirect.PIPE); // pb.redirectError(Redirect.PIPE); final Process p = pb.start(); // Sense of "input" and "output" are reversed between ProcessBuilder and Process p.getOutputStream().close(); // Child process sees EOF on stdin (if it reads stdin at all) Thread outPrinter = new Thread(new SubprocessPipePrinter(p.getInputStream(), System.out)); Thread errPrinter = new Thread(new SubprocessPipePrinter(p.getErrorStream(), System.out)); outPrinter.start(); errPrinter.start(); int stat = p.waitFor(); outPrinter.join(); errPrinter.join(); assertEquals(0, stat); } private static class SubprocessPipePrinter implements Runnable { private final BufferedReader source; private final PrintStream sink; private SubprocessPipePrinter(InputStream source, PrintStream sink) { this.source = new BufferedReader(new InputStreamReader(source)); this.sink = sink; } @Override public void run() { try { runUnsafe(); } catch (IOException e) { throw new RuntimeException(e); } catch (InterruptedException e) { // Exit silently } } private void runUnsafe() throws IOException, InterruptedException { String line = null; while (null != (line = source.readLine())) { synchronized (sink) { sink.println(line); } } } } }