/*
* 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.uima.tools.pear.merger;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.jar.JarFile;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.pear.tools.InstallationDescriptor;
import org.apache.uima.pear.tools.PackageBrowser;
import org.apache.uima.pear.util.FileUtil;
/**
* The <code>PMController</code> class allows to merge several input PEAR files in one PEAR file
* and generate an aggregate analysis engine from the components encapsulated in the input PEARs.
*
* @see org.apache.uima.tools.pear.merger.PMControllerHelper
* @see org.apache.uima.tools.pear.merger.PMUimaAgent
*/
public class PMController {
// utility name
static final String PEAR_MERGER = "PEAR Merger";
// log file name
static final String LOG_FILE = "pm.log";
// command line argument names
static final String AGGREGATE_NAME_ARG = "-n";
static final String AGGREGATE_PEAR_FILE_ARG = "-f";
// command line parameters
private static File[] __pearFiles = null;
private static String __aggregateName = null;
private static File __aggregatePearFile = null;
/**
* The <code>PMLogFormatter</code> class formats messages for the log file.
*/
static class PMLogFormatter extends SimpleFormatter {
private boolean _firstTime = true;
public String format(LogRecord record) {
if (_firstTime) {
// 1st time - print with header
_firstTime = false;
record.setSourceMethodName("");
return super.format(record);
} else {
// print level: message
StringBuffer buffer = new StringBuffer();
buffer.append(record.getLevel());
String message = record.getMessage();
// for multi-line msg - start msg in new line
if (message.indexOf('\n') >= 0)
buffer.append(": \n");
else
// for single line msg - start msg in the same line
buffer.append(": ");
buffer.append(record.getMessage());
buffer.append('\n');
return buffer.toString();
}
}
}
// static attributes
private static Logger __logger = null;
private static boolean __logFileEnabled = false;
// static Logger initialization
static {
// create default logger
__logger = Logger.getLogger(PMController.class.getName());
__logger.setUseParentHandlers(false);
}
// internal attributes
private File[] _inpPearFiles = null;
private String _outAggCompName = null;
private File _outAggPearFile = null;
private File _tempWorkDir = null;
private File _outAggRootDir = null;
private File[] _outDlgRootDirs = null;
private InstallationDescriptor[] _dlgInstDescs = null;
private InstallationDescriptor _outAggInstDesc = null;
/**
* The command line application entry point. This method expects the following command line
* arguments:
* <ul>
* <li>pear_file_1 ... pear_file_n - input PEAR files (required)</li>
* <li>-n agg_name - a name of the output aggregate analysis engine (required) </li>
* <li>-f agg_pear_file - output aggregate PEAR file (optional). <br />
* If the output PEAR file is not specified, the default output PEAR file is created in the
* current working directory.</li>
* </ul>
*
* @param args
* pear_file_1 ... pear_file_n -n agg_name [-f agg_pear_file]
*/
public static void main(String[] args) {
// enable log file
setLogFileEnabled(true);
// parse and validate command line
if (!parseCommandLine(args)) {
logErrorMessage(PEAR_MERGER + " terminated: command line error");
return;
}
PMController controller = null;
try {
// create controller object
controller = new PMController(__pearFiles, __aggregateName, __aggregatePearFile);
// merge input PEARs and create merged aggregate PEAR file
if (controller.mergePears()) {
logInfoMessage("[" + PEAR_MERGER + "]: " + "operation completed successfully");
} else
logInfoMessage("[" + PEAR_MERGER + "]: " + "operation failed");
} catch (Throwable err) {
logErrorMessage("Error in " + PEAR_MERGER + ": " + err.toString());
} finally {
if (controller != null) {
try {
controller.cleanUp();
} catch (Exception e) {
}
}
}
}
/**
* Returns the instance of the class-specific <code>Logger</code> object.
*
* @return The instance of the class-specific <code>Logger</code> object.
*/
public static Logger getLogger() {
return __logger;
}
/**
* Logs a given error message to the log file and prints it to the standard error console stream.
*
* @param message
* The given error message.
*/
public static void logErrorMessage(String message) {
if (__logFileEnabled)
getLogger().severe(message);
System.err.println(message);
}
/**
* Logs a given info message to the log file and prints it to the standard output console stream.
*
* @param message
* The given info message.
*/
public static void logInfoMessage(String message) {
if (__logFileEnabled)
getLogger().info(message);
System.out.println(message);
}
/**
* Logs a given warning message to the log file and prints it to the standard error console
* stream.
*
* @param message
* The given warning message.
*/
public static void logWarningMessage(String message) {
if (__logFileEnabled)
getLogger().warning(message);
System.err.println(message);
}
/**
* Parses and validates the command line and initializes static attributes.
*
* @param args
* The given command line arguments.
* @return <code>true</code>, if the command line arguments are valid, <code>false</code>
* otherwise.
*/
private static boolean parseCommandLine(String[] args) {
// verify command line args (min 4 args: p_1 p_2 -n name)
if (args.length < 4) {
logErrorMessage(PEAR_MERGER + " args: " + "pear_file_1 ... pear_file_n -n agg_name "
+ "[-f agg_pear_file]");
return false;
}
ArrayList listOfPears = new ArrayList();
// parse command line
for (int i = 0; i < args.length; i++) {
if (args[i].equals(AGGREGATE_NAME_ARG)) {
// set aggregate name
if (++i < args.length)
__aggregateName = args[i];
} else if (args[i].equals(AGGREGATE_PEAR_FILE_ARG)) {
// set aggregate PEAR file
if (++i < args.length)
__aggregatePearFile = new File(args[i]);
} else if (args[i].startsWith( "-" )) {
logErrorMessage(PEAR_MERGER + " error: " + "unknown flag '" + args[i] + "'");
return false;
} else {
// add next input PEAR file
File inPear = new File(args[i]);
if (inPear.isFile()) {
// make sure this is not duplicated input file
for (int n = 0; n < listOfPears.size(); n++) {
try {
String fPath = ((File) listOfPears.get(n)).getCanonicalPath();
String inPath = inPear.getCanonicalPath();
if (fPath.equals(inPath)) {
logErrorMessage(PEAR_MERGER + " error: " + "duplicated input file " + args[i]);
return false;
}
} catch (IOException e) {
logErrorMessage(PEAR_MERGER + " error: " + e.toString());
return false;
}
}
listOfPears.add(inPear);
} else {
logErrorMessage(PEAR_MERGER + " error: " + "cannot find input file " + args[i]);
return false;
}
}
}
// validate command line parameters and set input files
if (listOfPears.size() < 2) {
logErrorMessage(PEAR_MERGER + " error: " + "input PEAR files not specified");
return false;
} else {
__pearFiles = new File[listOfPears.size()];
listOfPears.toArray(__pearFiles);
}
if (__aggregateName == null) {
logErrorMessage(PEAR_MERGER + " error: " + "output aggregate name not specified");
return false;
}
return true;
}
/**
* Enables/disables PM log file. By default, the log file is disabled.
*
* @param enable
* if <code>true</code>, the log file is enabled, otherwise it is disabled.
*/
public static void setLogFileEnabled(boolean enable) {
if (enable) {
Handler[] handlers = getLogger().getHandlers();
if (handlers == null || handlers.length == 0) {
// add default file handler
try {
FileHandler fileHandler = new FileHandler(LOG_FILE, false);
fileHandler.setLevel(Level.ALL);
fileHandler.setFormatter(new PMLogFormatter());
getLogger().addHandler(fileHandler);
} catch (Throwable err) {
System.err.println("Error initializing log file " + PMController.class.getName() + ": "
+ err.toString());
}
}
}
__logFileEnabled = enable;
}
/**
* Constructor that takes a given array of input PEAR files, a given output component name (ID)
* and a given output PEAR file.
*
* @param inpPearFiles
* The given array of input PEAR files.
* @param outCompName
* The given output component name (ID).
* @param outPearFile
* The given output PEAR file.
* @exception IOException
* If any I/O exception occurred during initialization.
*/
public PMController(File[] inpPearFiles, String outCompName, File outPearFile) throws IOException {
// initialize task attributes
_inpPearFiles = inpPearFiles;
_outAggCompName = outCompName;
_outAggPearFile = outPearFile;
initializeTaskAttributes();
// log PEAR Merger task parameters
logInfoMessage("[" + PEAR_MERGER + "]: task parameters =>");
logInfoMessage("> Input PEARs =>");
for (int i = 0; i < _inpPearFiles.length; i++)
logInfoMessage(">> " + _inpPearFiles[i].getAbsolutePath());
logInfoMessage("> Output PEAR =>");
logInfoMessage(">> Name = " + _outAggCompName);
logInfoMessage(">> File = " + _outAggPearFile.getAbsolutePath());
logInfoMessage("> Output root dir: " + _outAggRootDir.getAbsolutePath());
}
/**
* Deletes all temporary directories and files after the merging operation is completed.
*
* @throws IOException
* If an I/O exception occurred.
*/
public void cleanUp() throws IOException {
logInfoMessage("[" + PEAR_MERGER + "]: " + "deleting temporary files");
FileUtil.deleteDirectory(_outAggRootDir);
}
/**
* Extracts all specified input PEARs to their corresponding folders inside the output root
* folder. Returns the total size (bytes) of extracted files.
*
* @return The total size of extracted files.
* @throws IOException
* If any I/O exception occurred during extraction.
*/
private long extractInputPears() throws IOException {
long totalSize = 0;
for (int i = 0; i < _inpPearFiles.length; i++) {
JarFile pearFile = new JarFile(_inpPearFiles[i]);
totalSize += FileUtil.extractFilesFromJar(pearFile, _outDlgRootDirs[i]);
}
return totalSize;
}
/**
* Intializes the 'PEAR Merger' task attributes, based on the specified input.
*
* @exception IOException
* If any I/O exception occurred during initialization.
*/
private void initializeTaskAttributes() throws IOException {
if (_outAggPearFile == null) // set default output file
_outAggPearFile = new File(_outAggCompName + ".pear");
// set temporary working directory
String userHomePath = System.getProperty("user.home");
_tempWorkDir = new File(userHomePath);
if (!_tempWorkDir.isDirectory())
throw new IOException(userHomePath + " directory not found");
// set output aggregate root directory
_outAggRootDir = new File(_tempWorkDir, _outAggCompName);
// if output aggregate root directory exists, remove it
if (_outAggRootDir.isDirectory()) {
if (!FileUtil.deleteDirectory(_outAggRootDir))
throw new IOException("cannot delete existing folder " + _outAggRootDir.getAbsolutePath());
} else if (_outAggRootDir.isFile()) {
if (!_outAggRootDir.delete())
throw new IOException("cannot delete existing file " + _outAggRootDir.getAbsolutePath());
}
// set output delegate root directories
_outDlgRootDirs = new File[_inpPearFiles.length];
for (int i = 0; i < _outDlgRootDirs.length; i++) {
String fileName = _inpPearFiles[i].getName();
String sdirName = fileName.substring(0, fileName.lastIndexOf('.'));
_outDlgRootDirs[i] = new File(_outAggRootDir, sdirName);
}
// prepare array for delegate installation descriptors
_dlgInstDescs = new InstallationDescriptor[_inpPearFiles.length];
}
/**
* Merges specified input PEARs into one PEAR, which encapsulates aggregate AE that refers to
* input components, as delegates. Returns <code>true</code>, if the merging operation
* completed successfully, <code>false</code> otherwise.
*
* @return <code>true</code>, if the merge operation completed successfully, <code>false</code>
* otherwise.
* @throws IOException
* If an I/O exception occurred during the merging operation.
*/
public boolean mergePears() throws IOException {
boolean done = false;
// 1st step: extract delegate PEARs to their target dirs
logInfoMessage("[" + PEAR_MERGER + "]: " + "extracting delegate PEARs ...");
long totalSize = extractInputPears();
logInfoMessage("[" + PEAR_MERGER + "]: " + totalSize + " bytes extracted successfully");
// 2nd step: process files in delegate packages and create InsD objs
for (int i = 0; i < _outDlgRootDirs.length; i++) {
_dlgInstDescs[i] = PMControllerHelper.processDescriptors(_outDlgRootDirs[i]);
if (_dlgInstDescs[i] == null) {
logErrorMessage("[" + PEAR_MERGER + "]: " + "failed to process input package in "
+ _outDlgRootDirs[i] + "directory");
break;
}
}
// 3rd step: generate merged package directory structure
File pkgDescDir = new File(_outAggRootDir, PackageBrowser.DESCRIPTORS_DIR);
File pkgMetadataDir = new File(_outAggRootDir, PackageBrowser.METADATA_DIR);
if (pkgDescDir.mkdirs() && pkgMetadataDir.mkdirs())
logInfoMessage("[" + PEAR_MERGER + "]: " + "created merged package directory structure");
else
throw new IOException("cannot create merged package folders");
// 4th step: generate aggregate component descriptor
File aggDescFile = new File(pkgDescDir, _outAggCompName + ".xml");
AnalysisEngineDescription aggDescription = PMUimaAgent.createAggregateDescription(
_outAggCompName, _outAggRootDir, _dlgInstDescs);
if (aggDescription != null) {
PMUimaAgent.saveAggregateDescription(aggDescription, aggDescFile);
logInfoMessage("[" + PEAR_MERGER + "]: " + "generated aggregate component descriptor");
if (System.getProperty("DEBUG") != null)
logInfoMessage(PMUimaAgent.toXmlString(aggDescription));
} else
throw new IOException("cannot generate aggregate component descriptor");
// 5th step: generate merged installation descriptor
_outAggInstDesc = PMControllerHelper.generateMergedInstallationDescriptor(_outAggRootDir,
_outAggCompName, aggDescFile, _dlgInstDescs, _outDlgRootDirs);
if (_outAggInstDesc != null) {
logInfoMessage("[" + PEAR_MERGER + "]: "
+ "generated aggregate package installation descriptor");
if (System.getProperty("DEBUG") != null)
logInfoMessage(_outAggInstDesc.toString());
// 6th step: create merged PEAR file
File outPearFile = FileUtil.zipDirectory(_outAggRootDir, _outAggPearFile);
logInfoMessage("[" + PEAR_MERGER + "]: " + "created output aggregate PEAR file - "
+ outPearFile.getAbsolutePath());
done = true;
}
return done;
}
}