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.yaess.bootstrap; import java.io.File; import java.io.IOException; import java.text.MessageFormat; import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.TreeMap; import org.apache.commons.cli.BasicParser; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.CommandLineParser; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.Option; import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.asakusafw.yaess.basic.ExitCodeException; import com.asakusafw.yaess.core.Blob; import com.asakusafw.yaess.core.ExecutionPhase; import com.asakusafw.yaess.core.Extension; import com.asakusafw.yaess.core.ProfileContext; import com.asakusafw.yaess.core.VariableResolver; import com.asakusafw.yaess.core.YaessLogger; import com.asakusafw.yaess.core.YaessProfile; import com.asakusafw.yaess.core.task.ExecutionTask; /** * A YAESS program main entry point. * @since 0.2.3 * @version 0.8.0 */ public final class Yaess { static final YaessLogger YSLOG = new YaessBootstrapLogger(Yaess.class); static final Logger LOG = LoggerFactory.getLogger(Yaess.class); static final String KEY_CUSTOM_PROFILE = "profile"; static final Option OPT_PROFILE; static final Option OPT_SCRIPT; static final Option OPT_BATCH_ID; static final Option OPT_FLOW_ID; static final Option OPT_EXECUTION_ID; static final Option OPT_PHASE_NAME; static final Option OPT_PLUGIN; static final Option OPT_ARGUMENT; static final Option OPT_DEFINITION; static final Option OPT_ENVIRONMENT_VARIABLE; private static final Options OPTIONS; static { OPT_PROFILE = new Option("profile", true, "profile path"); OPT_PROFILE.setArgName("/path/to/profile"); OPT_PROFILE.setRequired(true); OPT_SCRIPT = new Option("script", true, "script path"); OPT_SCRIPT.setArgName("/path/to/script"); OPT_SCRIPT.setRequired(true); OPT_BATCH_ID = new Option("batch", true, "batch ID"); OPT_BATCH_ID.setArgName("batch_id"); OPT_BATCH_ID.setRequired(true); OPT_FLOW_ID = new Option("flow", true, "flow ID"); OPT_FLOW_ID.setArgName("flow_id"); OPT_FLOW_ID.setRequired(false); OPT_EXECUTION_ID = new Option("execution", true, "execution ID"); OPT_EXECUTION_ID.setArgName("execution-id"); OPT_EXECUTION_ID.setRequired(false); OPT_PHASE_NAME = new Option("phase", true, "target phase name"); OPT_PHASE_NAME.setArgName("phase-name"); OPT_PHASE_NAME.setRequired(false); OPT_PLUGIN = new Option("plugin", true, "YAESS plug-ins"); OPT_PLUGIN.setArgName("plugin-1.jar" + File.pathSeparatorChar + "plugin-2.jar"); OPT_PLUGIN.setRequired(false); OPT_ARGUMENT = new Option("A", "argument", true, "batch argument"); OPT_ARGUMENT.setArgs(2); OPT_ARGUMENT.setValueSeparator('='); OPT_ARGUMENT.setArgName("name=value"); OPT_ARGUMENT.setRequired(false); OPT_DEFINITION = new Option("D", "define", true, "definitions"); OPT_DEFINITION.setArgs(2); OPT_DEFINITION.setValueSeparator('='); OPT_DEFINITION.setArgName("name=value"); OPT_DEFINITION.setRequired(false); OPT_ENVIRONMENT_VARIABLE = new Option("V", "variable", true, "extra environment variable"); OPT_ENVIRONMENT_VARIABLE.setArgs(2); OPT_ENVIRONMENT_VARIABLE.setValueSeparator('='); OPT_ENVIRONMENT_VARIABLE.setArgName("name=value"); OPT_ENVIRONMENT_VARIABLE.setRequired(false); OPTIONS = new Options(); OPTIONS.addOption(OPT_PROFILE); OPTIONS.addOption(OPT_SCRIPT); OPTIONS.addOption(OPT_BATCH_ID); OPTIONS.addOption(OPT_FLOW_ID); OPTIONS.addOption(OPT_EXECUTION_ID); OPTIONS.addOption(OPT_PHASE_NAME); OPTIONS.addOption(OPT_PLUGIN); OPTIONS.addOption(OPT_ARGUMENT); OPTIONS.addOption(OPT_DEFINITION); OPTIONS.addOption(OPT_ENVIRONMENT_VARIABLE); } private Yaess() { return; } /** * Program entry. * @param args program arguments */ public static void main(String... args) { CommandLineUtil.prepareLogContext(); YSLOG.info("I00000"); long start = System.currentTimeMillis(); int status = execute(args); long end = System.currentTimeMillis(); YSLOG.info("I00999", status, end - start); System.exit(status); } static int execute(String[] args) { assert args != null; Configuration conf; try { conf = parseConfiguration(args); } catch (Exception e) { HelpFormatter formatter = new HelpFormatter(); formatter.setWidth(Integer.MAX_VALUE); formatter.printHelp(MessageFormat.format("java -classpath ... {0}", Yaess.class.getName()), OPTIONS, true); System.out.println("Phase name is one of:"); for (ExecutionPhase phase : ExecutionPhase.values()) { System.out.printf(" %s%n", phase.getSymbol()); } YSLOG.error(e, "E00001", Arrays.toString(args)); return 1; } try { ExecutionTask task; try { Map<String, Blob> blobs = new LinkedHashMap<>(); for (Extension extension : conf.extensions) { blobs.put(extension.getName(), extension.getData()); } task = ExecutionTask.load(conf.profile, conf.script, conf.arguments, conf.definitions, blobs); } catch (Exception e) { YSLOG.error(e, "E00002", conf); return 1; } YSLOG.info("I00001", conf); switch (conf.mode) { case BATCH: task.executeBatch(conf.batchId); break; case FLOW: task.executeFlow(conf.batchId, conf.flowId, conf.executionId); break; case PHASE: task.executePhase(conf.batchId, conf.flowId, conf.executionId, conf.phase); break; default: throw new AssertionError(conf.mode); } return 0; } catch (ExitCodeException e) { YSLOG.error("E00003", conf); return 1; } catch (Exception e) { YSLOG.error(e, "E00003", conf); return 1; } finally { for (Extension ext : conf.extensions) { try { ext.close(); } catch (IOException e) { LOG.debug("error occurred while closing extension: {}", ext, e); //$NON-NLS-1$ } } } } static Configuration parseConfiguration(String[] args) throws ParseException { assert args != null; LOG.debug("Analyzing YAESS bootstrap arguments: {}", Arrays.toString(args)); ArgumentList argList = ArgumentList.parse(args); LOG.debug("Argument List: {}", argList); CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(OPTIONS, argList.getStandardAsArray()); String profile = cmd.getOptionValue(OPT_PROFILE.getOpt()); LOG.debug("Profile: {}", profile); String script = cmd.getOptionValue(OPT_SCRIPT.getOpt()); LOG.debug("Script: {}", script); String batchId = cmd.getOptionValue(OPT_BATCH_ID.getOpt()); LOG.debug("Batch ID: {}", batchId); String flowId = cmd.getOptionValue(OPT_FLOW_ID.getOpt()); LOG.debug("Flow ID: {}", flowId); String executionId = cmd.getOptionValue(OPT_EXECUTION_ID.getOpt()); LOG.debug("Execution ID: {}", executionId); String phaseName = cmd.getOptionValue(OPT_PHASE_NAME.getOpt()); LOG.debug("Phase name: {}", phaseName); String plugins = cmd.getOptionValue(OPT_PLUGIN.getOpt()); LOG.debug("Plug-ins: {}", plugins); Properties arguments = cmd.getOptionProperties(OPT_ARGUMENT.getOpt()); LOG.debug("Execution arguments: {}", arguments); Properties variables = cmd.getOptionProperties(OPT_ENVIRONMENT_VARIABLE.getOpt()); LOG.debug("Environment variables: {}", variables); Properties definitions = cmd.getOptionProperties(OPT_DEFINITION.getOpt()); LOG.debug("YAESS feature definitions: {}", definitions); LOG.debug("Loading plugins: {}", plugins); List<File> pluginFiles = CommandLineUtil.parseFileList(plugins); ClassLoader loader = CommandLineUtil.buildPluginLoader(Yaess.class.getClassLoader(), pluginFiles); Configuration result = new Configuration(); result.mode = computeMode(flowId, executionId, phaseName); LOG.debug("Loading profile: {}", profile); File file = new File(profile); file = findCustomProfile(file, definitions.getProperty(KEY_CUSTOM_PROFILE)); try { definitions.remove(KEY_CUSTOM_PROFILE); Map<String, String> env = new HashMap<>(); env.putAll(System.getenv()); env.putAll(toMap(variables)); result.context = new ProfileContext(loader, new VariableResolver(env)); Properties properties = CommandLineUtil.loadProperties(file); result.profile = YaessProfile.load(properties, result.context); } catch (Exception e) { YSLOG.error(e, "E01001", file.getPath()); throw new IllegalArgumentException(MessageFormat.format("Invalid profile \"{0}\".", file), e); } LOG.debug("Loading script: {}", script); try { Properties properties = CommandLineUtil.loadProperties(new File(script)); result.script = properties; } catch (Exception e) { YSLOG.error(e, "E01002", script); throw new IllegalArgumentException(MessageFormat.format("Invalid script \"{0}\".", script), e); } result.batchId = batchId; result.flowId = flowId; result.executionId = executionId; if (phaseName != null) { result.phase = ExecutionPhase.findFromSymbol(phaseName); if (result.phase == null) { throw new IllegalArgumentException(MessageFormat.format("Unknown phase name \"{0}\".", phaseName)); } } result.arguments = toMap(arguments); result.definitions = toMap(definitions); result.extensions = CommandLineUtil.loadExtensions(loader, argList.getExtended()); LOG.debug("Analyzed YAESS bootstrap arguments"); return result; } private static File findCustomProfile(File file, String customProfileName) { if (customProfileName == null) { return file; } String fileName = file.getName(); int index = fileName.lastIndexOf('.'); String extension = ""; //$NON-NLS-1$ if (index >= 0) { extension = fileName.substring(index); } File result = new File(file.getParentFile(), customProfileName + extension); YSLOG.info("I01001", //$NON-NLS-1$ result); return result; } private static Map<String, String> toMap(Properties p) { assert p != null; Map<String, String> results = new TreeMap<>(); for (Map.Entry<Object, Object> entry : p.entrySet()) { results.put((String) entry.getKey(), (String) entry.getValue()); } return results; } private static Mode computeMode(String flowId, String executionId, String phaseName) { if (flowId == null) { if (executionId != null) { throw new IllegalArgumentException( MessageFormat.format("Argument \"-{0}\" must NOT be set if \"-{1}\" does not exists", OPT_EXECUTION_ID.getOpt(), OPT_FLOW_ID.getOpt())); } if (phaseName != null) { throw new IllegalArgumentException( MessageFormat.format("Argument \"-{0}\" must NOT be set if \"-{1}\" does not exists", OPT_PHASE_NAME.getOpt(), OPT_FLOW_ID.getOpt())); } return Mode.BATCH; } else { if (executionId == null) { throw new IllegalArgumentException( MessageFormat.format("Argument \"-{0}\" must be set if \"-{1}\" exists", OPT_EXECUTION_ID.getOpt(), OPT_FLOW_ID.getOpt())); } if (phaseName == null) { return Mode.FLOW; } else { return Mode.PHASE; } } } static final class Configuration { Mode mode; ProfileContext context; YaessProfile profile; Properties script; String batchId; String flowId; String executionId; ExecutionPhase phase; Map<String, String> arguments; Map<String, String> definitions; List<Extension> extensions; @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append("Configuration [mode="); builder.append(mode); builder.append(", batchId="); builder.append(batchId); builder.append(", arguments="); builder.append(arguments); builder.append(", definitions="); builder.append(definitions); if (flowId != null) { builder.append(", flowId="); builder.append(flowId); } if (executionId != null) { builder.append(", executionId="); builder.append(executionId); } if (phase != null) { builder.append(", phase="); builder.append(phase); } builder.append("]"); return builder.toString(); } } enum Mode { BATCH, FLOW, PHASE, } }