/**
* Loads a {@link ExecutionScript}s in the specified flow and phase. If the target phase is empty
* in the specified flow, this returns an empty list. Note that this method will raise an
* exception if the specified flow does not exist.
*
* @param properties source properties
* @param flowId the target flow ID
* @param phase the target phase
* @return the loaded execution scripts
* @throws IllegalArgumentException if script is invalid, or some parameters were {@code null}
* @see #extractFlowIds(Properties)
*/
public static Set<ExecutionScript> load(
Properties properties, String flowId, ExecutionPhase phase) {
if (properties == null) {
throw new IllegalArgumentException("properties must not be null"); // $NON-NLS-1$
}
if (flowId == null) {
throw new IllegalArgumentException("flowId must not be null"); // $NON-NLS-1$
}
if (phase == null) {
throw new IllegalArgumentException("phase must not be null"); // $NON-NLS-1$
}
String prefix = getPrefix(flowId, phase);
LOG.debug("Loading execution scripts: {}*", prefix);
Set<String> availableFlowIds = extractFlowIds(properties);
if (availableFlowIds.contains(flowId) == false) {
throw new IllegalArgumentException(
MessageFormat.format("Flow \"{0}\" does not exist", flowId));
}
NavigableMap<String, String> contents = PropertiesUtil.createPrefixMap(properties, prefix);
List<ExecutionScript> scripts = loadScripts(flowId, phase, contents);
LOG.debug("Loaded {} execution scripts: {}*", scripts.size(), prefix);
LOG.trace("Loaded {}*: {}", prefix, scripts);
TreeSet<ExecutionScript> results = new TreeSet<ExecutionScript>(SCRIPT_COMPARATOR);
results.addAll(scripts);
return results;
}
private static ExecutionScript loadScript(
String flowId, ExecutionPhase phase, String nodeId, Map<String, String> contents) {
assert flowId != null;
assert phase != null;
assert nodeId != null;
assert contents != null;
String prefix = getPrefix(flowId, phase, nodeId);
String scriptId = extract(contents, prefix, KEY_ID);
String kindSymbol = extract(contents, prefix, KEY_KIND);
ExecutionScript.Kind kind = ExecutionScript.Kind.findFromSymbol(kindSymbol);
String blockersString = extract(contents, prefix, KEY_BLOCKERS);
Set<String> blockers = parseTokens(blockersString);
Map<String, String> environmentVariables =
PropertiesUtil.createPrefixMap(contents, KEY_ENV_PREFIX);
ExecutionScript script;
if (kind == ExecutionScript.Kind.COMMAND) {
String profileName = extract(contents, prefix, KEY_PROFILE);
String moduleName = extract(contents, prefix, KEY_MODULE);
NavigableMap<String, String> commandMap =
PropertiesUtil.createPrefixMap(contents, KEY_COMMAND_PREFIX);
if (commandMap.isEmpty()) {
throw new IllegalArgumentException(
MessageFormat.format("\"{0}*\" is not defined", prefix + KEY_COMMAND_PREFIX));
}
List<String> command = new ArrayList<String>(commandMap.values());
script =
new CommandScript(
scriptId, blockers, profileName, moduleName, command, environmentVariables);
} else if (kind == ExecutionScript.Kind.HADOOP) {
String className = extract(contents, prefix, KEY_CLASS_NAME);
Map<String, String> properties = PropertiesUtil.createPrefixMap(contents, KEY_PROP_PREFIX);
script = new HadoopScript(scriptId, blockers, className, properties, environmentVariables);
} else {
throw new IllegalArgumentException(
MessageFormat.format("Unsupported kind in \"{0}\": {1}", prefix + KEY_KIND, kindSymbol));
}
LOG.trace("Loaded script {}* -> {}", script);
return script;
}
/**
* Returns all flow IDs defined in the properties.
*
* @param properties target properties
* @return all flow IDs
* @throws IllegalArgumentException if some parameters were {@code null}
*/
public static Set<String> extractFlowIds(Properties properties) {
if (properties == null) {
throw new IllegalArgumentException("properties must not be null"); // $NON-NLS-1$
}
LOG.debug("Extracting Flow IDs");
Set<String> childKeys =
PropertiesUtil.getChildKeys(properties, KEY_FLOW_PREFIX, String.valueOf('.'));
int prefixLength = KEY_FLOW_PREFIX.length();
Set<String> results = new TreeSet<String>();
for (String childKey : childKeys) {
assert childKey.startsWith(KEY_FLOW_PREFIX);
results.add(childKey.substring(prefixLength));
}
LOG.debug("Extracted Flow IDs: {}", results);
return results;
}
/**
* Loads a {@link FlowScript} with the specified ID.
*
* @param properties source properties
* @param flowId the target flow ID
* @return the loaded script
* @throws IllegalArgumentException if script is invalid, or some parameters were {@code null}
* @see #extractFlowIds(Properties)
*/
public static FlowScript load(Properties properties, String flowId) {
if (properties == null) {
throw new IllegalArgumentException("properties must not be null"); // $NON-NLS-1$
}
if (flowId == null) {
throw new IllegalArgumentException("flowId must not be null"); // $NON-NLS-1$
}
String prefix = getPrefix(flowId);
LOG.debug("Loading execution scripts: {}*", prefix);
NavigableMap<String, String> flowMap = PropertiesUtil.createPrefixMap(properties, prefix);
String blockersString = extract(flowMap, prefix, KEY_BLOCKERS);
Set<String> blockerIds = parseTokens(blockersString);
EnumMap<ExecutionPhase, List<ExecutionScript>> scripts =
new EnumMap<ExecutionPhase, List<ExecutionScript>>(ExecutionPhase.class);
for (ExecutionPhase phase : ExecutionPhase.values()) {
scripts.put(phase, Collections.<ExecutionScript>emptyList());
}
int count = 0;
Map<String, NavigableMap<String, String>> phaseMap = partitioning(flowMap);
for (Map.Entry<String, NavigableMap<String, String>> entry : phaseMap.entrySet()) {
String phaseSymbol = entry.getKey();
NavigableMap<String, String> phaseContents = entry.getValue();
ExecutionPhase phase = ExecutionPhase.findFromSymbol(phaseSymbol);
if (phase == null) {
throw new IllegalArgumentException(
MessageFormat.format("Unknown phase in \"{0}\": {1}", flowId, phaseSymbol));
}
List<ExecutionScript> scriptsInPhase = loadScripts(flowId, phase, phaseContents);
scripts.put(phase, scriptsInPhase);
count += scriptsInPhase.size();
}
FlowScript script = new FlowScript(flowId, blockerIds, scripts);
LOG.debug("Loaded {} execution scripts: {}*", count, prefix);
LOG.trace("Loaded {}*: {}", prefix, script);
return script;
}