/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.felix.ipojo.task;
import static java.lang.String.format;
import org.apache.commons.cli.*;
import org.apache.felix.ipojo.manipulator.Pojoization;
import org.apache.felix.ipojo.manipulator.util.Constants;
import java.io.File;
import java.util.List;
/**
* A command line tools to manipulate iPOJO bundles.
* It can be used as follow:
* <code>java -jar this-jar.jar --input the-jar-to-manipulate</code><br/>
* <code>java -jar this-jar.jar --input the-jar-to-manipulate --output the-output-jar</code><br/>
* <code>java -jar this-jar.jar --input the-jar-to-manipulate --metadata the-xml-metadata</code><br/>
*/
public class IPojoc {
/**
* Input file to be manipulated.
*/
private File m_input;
/**
* Output file (temporary or not).
*/
private File m_output;
/**
* Metadata file (may be null).
*/
private File m_metadata;
/**
* Manipulator.
*/
private Pojoization m_pojoization;
/**
* The main entry point
* @param args the arguments
*/
public static void main(String[] args) {
Options options = buildOptions();
CommandLine cmd = null;
try {
cmd = buildCommandLine(args, options);
if (cmd.hasOption('h')) {
printHelp(options);
} else {
IPojoc compiler = new IPojoc();
compiler.execute(cmd);
}
} catch (MissingOptionException e) {
for (String opt : (List<String>) e.getMissingOptions()) {
System.err.println("The '" + opt + "' option is missing");
}
printHelp(options);
} catch (MissingArgumentException e) {
System.err.println("The option '" + e.getOption() + "' requires an argument");
printHelp(options);
} catch (Exception e) {
System.out.printf("Manipulation failed: %s%n", e.getMessage());
if ((cmd != null) && cmd.hasOption('X')) {
e.printStackTrace(System.out);
} else {
System.out.printf("Use -X option to print the full stack trace%n");
}
}
}
private static CommandLine buildCommandLine(final String[] args, final Options options) throws ParseException {
CommandLineParser parser = new GnuParser();
return parser.parse(options, args);
}
/**
* The command line is valid, to processing the command line.
* @param cmd the command line
* @throws ParseException
*/
private void execute(CommandLine cmd) throws Exception {
System.out.printf("iPOJO Manipulation (%s)%n", Constants.getVersion());
System.out.println("-----------------------------------------------");
readInputOption(cmd);
readOutputOption(cmd);
readMetadataOption(cmd);
manipulate();
printStatus();
}
private void readMetadataOption(final CommandLine cmd) throws Exception {
// Retrieve the metadata file
if (cmd.hasOption("m")) {
m_metadata = (File) cmd.getParsedOptionValue("m");
if (m_metadata != null && !m_metadata.isFile()) {
throw new Exception(
format("The metadata option must be an existing file, '%s' does not exist", cmd.getOptionValue('m'))
);
}
System.out.println("metadata file => " + m_metadata.getAbsolutePath());
} else {
System.out.println("metadata file => no metadata file");
}
}
private void readOutputOption(final CommandLine cmd) throws Exception {
// Retrieve output file
if (cmd.hasOption("o")) {
try {
m_output = (File) cmd.getParsedOptionValue("o");
} catch (ParseException pe) {
throw new Exception(
format("The output option must be an existing file, '%s' does not exist", cmd.getOptionValue('o'))
);
}
System.out.println("output file => " + m_output.getAbsolutePath());
} else {
// Inline replacement
// We create a temporary file marked by a __ prefix
// It will be substituted upon success.
m_output = new File("__" + m_input.getName());
System.out.println("output file => " + m_input.getAbsolutePath());
}
}
private void readInputOption(final CommandLine cmd) throws Exception {
// Check that the input file exist
m_input = (File) cmd.getParsedOptionValue("i");
if (m_input == null || !m_input.isFile()) {
throw new Exception(
format("The input option must be an existing file, '%s' does not exist", cmd.getOptionValue('i'))
);
}
System.out.println("input file => " + m_input.getAbsolutePath());
}
private void manipulate() {
m_pojoization = new Pojoization();
m_pojoization.pojoization(m_input, m_output, m_metadata);
}
private void printStatus() {
if (m_pojoization.getErrors().size() != 0) {
System.err.println("iPOJO Manipulation failed :");
for (String error : m_pojoization.getErrors()) {
System.err.println("\t" + error);
}
System.exit(-1);
} else {
System.err.println("iPOJO Manipulation successfully completed.");
for (String warning : m_pojoization.getWarnings()) {
System.err.println(warning);
}
cleanup();
System.exit(0);
}
}
/**
* Upon success, cleanup temporary files.
*/
private void cleanup() {
if (m_output.getName().startsWith("__")) {
m_input.delete();
m_output.renameTo(m_input);
}
}
/**
* Print help.
* @param options
*/
private static void printHelp(final Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("java -jar org.apache.felix.ipojo.ant-" + Constants.getVersion() + ".jar", options);
}
/**
* Builds the option list
* @return the options
*/
public static Options buildOptions() {
Option input =
OptionBuilder.withArgName("input file")
.withLongOpt("input")
.hasArg()
.withDescription("the input jar file")
.isRequired(true)
.withType(File.class)
.create('i');
Option output =
OptionBuilder
.withLongOpt("output")
.withArgName("output file")
.hasArg()
.withDescription("the output jar file, if not set the manipulation replaces the input file")
.isRequired(false)
.withType(File.class)
.create('o');
Option metadata =
OptionBuilder
.withLongOpt("metadata")
.withArgName("metadata file")
.hasArg()
.withDescription("the XML metadata file")
.isRequired(false)
.withType(File.class)
.create('m');
Option verbose = new Option("X", "exception", false, "print exception stack trace in case of error");
Option help =
OptionBuilder.withLongOpt("help").withDescription("print this message").create('h');
return new Options()
.addOption(input)
.addOption(output)
.addOption(metadata)
.addOption(verbose)
.addOption(help);
}
}