uimaj-ep-launcher/src/main/java/org/apache/uima/ep_launcher/RemoteLauncher.java - uima-uimaj - Git at Google

 /*
  * 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.ep_launcher;

 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 import org.apache.uima.UIMAFramework;
 import org.apache.uima.analysis_engine.AnalysisEngine;
 import org.apache.uima.analysis_engine.AnalysisEngineProcessException;
 import org.apache.uima.cas.CAS;
 import org.apache.uima.cas.impl.XCASDeserializer;
 import org.apache.uima.cas.impl.XmiCasDeserializer;
 import org.apache.uima.cas.impl.XmiCasSerializer;
 import org.apache.uima.ep_launcher.LauncherConstants.InputFormat;
 import org.apache.uima.resource.ResourceSpecifier;
 import org.apache.uima.util.FileUtils;
 import org.apache.uima.util.XMLInputSource;
 import org.apache.uima.util.XMLSerializer;
 import org.apache.uima.util.impl.ProcessTrace_impl;
 import org.xml.sax.SAXException;

 /**
  * The RemoteLauncher runs the actual Analysis Engine in the launched VM.
  */
 public class RemoteLauncher {

   public static final String DESCRIPTOR_PARAM = "-descriptor";
   public static final String INPUT_RESOURCE_PARAM = "-inputResource";
   public static final String INPUT_RECURSIVE_PARAM = "-recursive";
   public static final String INPUT_FORMAT_PARAM = "-format";
   public static final String INPUT_ENCODING_PARAM = "-encoding";
   public static final String INPUT_LANGUAGE_PARAM = "-language";
   public static final String OUTPUT_FOLDER_PARAM = "-output";
   public static final String OUTPUT_CLEAR_PARAM = "-clear";

   private static File descriptor;
   private static File inputResource;
   private static boolean inputRecursive;
   private static InputFormat inputFormat = InputFormat.CAS;
   private static String inputEncoding = java.nio.charset.Charset.defaultCharset().name();
   private static String inputLanguage;
   private static File outputFolder;
   private static boolean outputFolderClear;

   private static boolean parseCmdLineArgs(String[] args) {

     int necessaryArgCount = 0;

     int index = 0;
     while (index < args.length) {

       String arg = args[index++];

       if (DESCRIPTOR_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         descriptor = new File(args[index++]);
         necessaryArgCount++;
       }
       else if (INPUT_RESOURCE_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         inputResource = new File(args[index++]);
         necessaryArgCount++;
       }
       else if (INPUT_RECURSIVE_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         inputRecursive = Boolean.parseBoolean(args[index++]);
       }
       else if (INPUT_FORMAT_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         String inputFormatName = args[index++];

         if (InputFormat.CAS.toString().equals(inputFormatName)) {
           inputFormat = InputFormat.CAS;
         }
         else if (InputFormat.PLAIN_TEXT.toString().equals(inputFormatName)) {
           inputFormat = InputFormat.PLAIN_TEXT;
         }
         else {
           System.err.println("Unkown input format: " + inputFormatName);
           return false;
         }

       }
       else if (INPUT_ENCODING_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         inputEncoding = args[index++];
       }
       else if (INPUT_LANGUAGE_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         inputLanguage = args[index++];
       }
       else if (OUTPUT_FOLDER_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         outputFolder = new File(args[index++]);
       }
       else if (OUTPUT_CLEAR_PARAM.equals(arg)) {
         if (index >= args.length) {
           return false;
         }

         outputFolderClear = Boolean.parseBoolean(args[index++]);
       }
     }

     return necessaryArgCount == 2;
   }

   private static void processFile(File inputFile, InputFormat format,
           AnalysisEngine aAE, CAS aCAS) throws IOException,
           AnalysisEngineProcessException {

     if (InputFormat.PLAIN_TEXT.equals(format)) {
       String document = FileUtils.file2String(inputFile, inputEncoding);
       document = document.trim();

       // put document text in CAS
       aCAS.setDocumentText(document);

       if (inputLanguage != null)
         aCAS.setDocumentLanguage(inputLanguage);
     }
     else if (InputFormat.CAS.equals(format)) {
       if (inputFile.getName().endsWith(".xmi")) {
         FileInputStream inputStream = new FileInputStream(inputFile);
         try {
           XmiCasDeserializer.deserialize(inputStream, aCAS, true);
         } catch (SAXException e) {
           throw new IOException(e.getMessage());
         } finally {
           inputStream.close();
         }
       }
       else if (inputFile.getName().endsWith(".xcas")) {
         FileInputStream inputStream = new FileInputStream(inputFile);
         try {
           XCASDeserializer.deserialize(inputStream, aCAS, true);
         } catch (SAXException e) {
           throw new IOException(e.getMessage());
         } finally {
           inputStream.close();
         }
       }
     }
     else {
       throw new IllegalStateException("Unexpected format!");
     }

     // process
     aAE.process(aCAS);

     if (outputFolder != null) {

       File inputDirectory;
       if (inputResource.isFile()) {
         inputDirectory = inputResource.getParentFile();
       }
       else {
         inputDirectory = inputResource;
       }

       String inputFilePath = inputFile.getPath();
       String relativeInputFilePath;
       if (inputFilePath.startsWith(inputDirectory.getPath())) {
         relativeInputFilePath = inputFilePath.substring(inputDirectory.getPath().length());
       }
       else {
         System.err.println("Error: Unable to construct output file path, output file will not be written!");
         return;
       }

       String outputFilePath = new File(outputFolder.getPath(), relativeInputFilePath).getPath();

       // cutoff file ending
       int fileTypeIndex = outputFilePath.lastIndexOf(".");
       if (fileTypeIndex != -1) {
         outputFilePath = outputFilePath.substring(0, fileTypeIndex);
       }

       File outputFile = new File(outputFilePath + ".xmi");

       // Create sub-directories
       if (!outputFile.getParentFile().exists()) {
         outputFile.getParentFile().mkdirs();
       }

       FileOutputStream out = new FileOutputStream(outputFile);

       try {
         // write XMI
         XmiCasSerializer ser = new XmiCasSerializer(aCAS.getTypeSystem());
         XMLSerializer xmlSer = new XMLSerializer(out, false);
         try {
           ser.serialize(aCAS, xmlSer.getContentHandler());
         } catch (SAXException e) {
           throw new IOException(e.getMessage());
         }
       } finally {
         if (out != null) {
           out.close();
         }
       }
     }

     // reset the CAS to prepare it for processing the next document
     aCAS.reset();
   }

   private static void findAndProcessFiles(File inputResource, FileFilter fileFilter,
           AnalysisEngine aAE, CAS aCAS) throws IOException,
           AnalysisEngineProcessException {

     // Figure out if input resource is file or directory
     if (inputResource.isDirectory()) {
       // get all files in the input directory
       File[] files = inputResource.listFiles(fileFilter);
       if (files != null) {
         for (int i = 0; i < files.length; i++) {
           if (!files[i].isDirectory()) {
             processFile(files[i], inputFormat, aAE, aCAS);
           }
           else {
             findAndProcessFiles(files[i], fileFilter, aAE, aCAS);
           }
         }
       }
     }
     else if (inputResource.isFile()) {
       // Just process the single file
       processFile(inputResource, inputFormat, aAE, aCAS);
     }
   }

   private static boolean deleteFile(File file) {

     if (file.isDirectory()) {
       File subFiles[] = file.listFiles();

       boolean success = true;
       for (File subFile : subFiles) {
         success = success && deleteFile(subFile);
       }

       return success;
     }
     else {
       return file.delete();
     }
   }

   public static void main(String[] args) throws Exception {

     if (!parseCmdLineArgs(args)) {
       throw new IllegalArgumentException("Passed arguments are invalid!");
     }

     if (outputFolder != null && outputFolderClear) {
       File filesToDelete[] = outputFolder.listFiles();

       for (File file : filesToDelete) {
         deleteFile(file);
       }
     }

     // get Resource Specifier from XML file
     XMLInputSource in = new XMLInputSource(descriptor);
     ResourceSpecifier specifier = UIMAFramework.getXMLParser().parseResourceSpecifier(in);

     // create Analysis Engine
     AnalysisEngine ae = UIMAFramework.produceAnalysisEngine(specifier);

     // create a CAS
     CAS cas = ae.newCAS();

     // Create a file filter depending on the format
     // to filter out all file which do not have the
     // expected file ending
     FileFilter fileFilter;
     if (InputFormat.CAS.equals(inputFormat)) {
       fileFilter = new FileFilter() {

         public boolean accept(File file) {
           return file.getName().endsWith(".xmi") || file.getName().endsWith(".xcas") ||
                   (inputRecursive && file.isDirectory());
         }
       };
     }
     else if (InputFormat.PLAIN_TEXT.equals(inputFormat)) {
       fileFilter = new FileFilter() {

         public boolean accept(File file) {
           return file.getName().endsWith(".txt") || (inputRecursive && file.isDirectory());
         }
       };
     }
     else {
       throw new IllegalStateException("Unexpected input format!");
     }

     findAndProcessFiles(inputResource, fileFilter, ae, cas);

     ae.collectionProcessComplete(new ProcessTrace_impl());
     ae.destroy();
   }
 }
	/*
	* 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.ep_launcher;

	import java.io.File;
	import java.io.FileFilter;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;

	import org.apache.uima.UIMAFramework;
	import org.apache.uima.analysis_engine.AnalysisEngine;
	import org.apache.uima.analysis_engine.AnalysisEngineProcessException;
	import org.apache.uima.cas.CAS;
	import org.apache.uima.cas.impl.XCASDeserializer;
	import org.apache.uima.cas.impl.XmiCasDeserializer;
	import org.apache.uima.cas.impl.XmiCasSerializer;
	import org.apache.uima.ep_launcher.LauncherConstants.InputFormat;
	import org.apache.uima.resource.ResourceSpecifier;
	import org.apache.uima.util.FileUtils;
	import org.apache.uima.util.XMLInputSource;
	import org.apache.uima.util.XMLSerializer;
	import org.apache.uima.util.impl.ProcessTrace_impl;
	import org.xml.sax.SAXException;

	/**
	* The RemoteLauncher runs the actual Analysis Engine in the launched VM.
	*/
	public class RemoteLauncher {

	public static final String DESCRIPTOR_PARAM = "-descriptor";
	public static final String INPUT_RESOURCE_PARAM = "-inputResource";
	public static final String INPUT_RECURSIVE_PARAM = "-recursive";
	public static final String INPUT_FORMAT_PARAM = "-format";
	public static final String INPUT_ENCODING_PARAM = "-encoding";
	public static final String INPUT_LANGUAGE_PARAM = "-language";
	public static final String OUTPUT_FOLDER_PARAM = "-output";
	public static final String OUTPUT_CLEAR_PARAM = "-clear";

	private static File descriptor;
	private static File inputResource;
	private static boolean inputRecursive;
	private static InputFormat inputFormat = InputFormat.CAS;
	private static String inputEncoding = java.nio.charset.Charset.defaultCharset().name();
	private static String inputLanguage;
	private static File outputFolder;
	private static boolean outputFolderClear;

	private static boolean parseCmdLineArgs(String[] args) {

	int necessaryArgCount = 0;

	int index = 0;
	while (index < args.length) {

	String arg = args[index++];

	if (DESCRIPTOR_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	descriptor = new File(args[index++]);
	necessaryArgCount++;
	}
	else if (INPUT_RESOURCE_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	inputResource = new File(args[index++]);
	necessaryArgCount++;
	}
	else if (INPUT_RECURSIVE_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	inputRecursive = Boolean.parseBoolean(args[index++]);
	}
	else if (INPUT_FORMAT_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	String inputFormatName = args[index++];

	if (InputFormat.CAS.toString().equals(inputFormatName)) {
	inputFormat = InputFormat.CAS;
	}
	else if (InputFormat.PLAIN_TEXT.toString().equals(inputFormatName)) {
	inputFormat = InputFormat.PLAIN_TEXT;
	}
	else {
	System.err.println("Unkown input format: " + inputFormatName);
	return false;
	}

	}
	else if (INPUT_ENCODING_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	inputEncoding = args[index++];
	}
	else if (INPUT_LANGUAGE_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	inputLanguage = args[index++];
	}
	else if (OUTPUT_FOLDER_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	outputFolder = new File(args[index++]);
	}
	else if (OUTPUT_CLEAR_PARAM.equals(arg)) {
	if (index >= args.length) {
	return false;
	}

	outputFolderClear = Boolean.parseBoolean(args[index++]);
	}
	}

	return necessaryArgCount == 2;
	}

	private static void processFile(File inputFile, InputFormat format,
	AnalysisEngine aAE, CAS aCAS) throws IOException,
	AnalysisEngineProcessException {

	if (InputFormat.PLAIN_TEXT.equals(format)) {
	String document = FileUtils.file2String(inputFile, inputEncoding);
	document = document.trim();

	// put document text in CAS
	aCAS.setDocumentText(document);

	if (inputLanguage != null)
	aCAS.setDocumentLanguage(inputLanguage);
	}
	else if (InputFormat.CAS.equals(format)) {
	if (inputFile.getName().endsWith(".xmi")) {
	FileInputStream inputStream = new FileInputStream(inputFile);
	try {
	XmiCasDeserializer.deserialize(inputStream, aCAS, true);
	} catch (SAXException e) {
	throw new IOException(e.getMessage());
	} finally {
	inputStream.close();
	}
	}
	else if (inputFile.getName().endsWith(".xcas")) {
	FileInputStream inputStream = new FileInputStream(inputFile);
	try {
	XCASDeserializer.deserialize(inputStream, aCAS, true);
	} catch (SAXException e) {
	throw new IOException(e.getMessage());
	} finally {
	inputStream.close();
	}
	}
	}
	else {
	throw new IllegalStateException("Unexpected format!");
	}

	// process
	aAE.process(aCAS);

	if (outputFolder != null) {

	File inputDirectory;
	if (inputResource.isFile()) {
	inputDirectory = inputResource.getParentFile();
	}
	else {
	inputDirectory = inputResource;
	}

	String inputFilePath = inputFile.getPath();
	String relativeInputFilePath;
	if (inputFilePath.startsWith(inputDirectory.getPath())) {
	relativeInputFilePath = inputFilePath.substring(inputDirectory.getPath().length());
	}
	else {
	System.err.println("Error: Unable to construct output file path, output file will not be written!");
	return;
	}

	String outputFilePath = new File(outputFolder.getPath(), relativeInputFilePath).getPath();

	// cutoff file ending
	int fileTypeIndex = outputFilePath.lastIndexOf(".");
	if (fileTypeIndex != -1) {
	outputFilePath = outputFilePath.substring(0, fileTypeIndex);
	}

	File outputFile = new File(outputFilePath + ".xmi");

	// Create sub-directories
	if (!outputFile.getParentFile().exists()) {
	outputFile.getParentFile().mkdirs();
	}

	FileOutputStream out = new FileOutputStream(outputFile);

	try {
	// write XMI
	XmiCasSerializer ser = new XmiCasSerializer(aCAS.getTypeSystem());
	XMLSerializer xmlSer = new XMLSerializer(out, false);
	try {
	ser.serialize(aCAS, xmlSer.getContentHandler());
	} catch (SAXException e) {
	throw new IOException(e.getMessage());
	}
	} finally {
	if (out != null) {
	out.close();
	}
	}
	}

	// reset the CAS to prepare it for processing the next document
	aCAS.reset();
	}

	private static void findAndProcessFiles(File inputResource, FileFilter fileFilter,
	AnalysisEngine aAE, CAS aCAS) throws IOException,
	AnalysisEngineProcessException {

	// Figure out if input resource is file or directory
	if (inputResource.isDirectory()) {
	// get all files in the input directory
	File[] files = inputResource.listFiles(fileFilter);
	if (files != null) {
	for (int i = 0; i < files.length; i++) {
	if (!files[i].isDirectory()) {
	processFile(files[i], inputFormat, aAE, aCAS);
	}
	else {
	findAndProcessFiles(files[i], fileFilter, aAE, aCAS);
	}
	}
	}
	}
	else if (inputResource.isFile()) {
	// Just process the single file
	processFile(inputResource, inputFormat, aAE, aCAS);
	}
	}

	private static boolean deleteFile(File file) {

	if (file.isDirectory()) {
	File subFiles[] = file.listFiles();

	boolean success = true;
	for (File subFile : subFiles) {
	success = success && deleteFile(subFile);
	}

	return success;
	}
	else {
	return file.delete();
	}
	}

	public static void main(String[] args) throws Exception {

	if (!parseCmdLineArgs(args)) {
	throw new IllegalArgumentException("Passed arguments are invalid!");
	}

	if (outputFolder != null && outputFolderClear) {
	File filesToDelete[] = outputFolder.listFiles();

	for (File file : filesToDelete) {
	deleteFile(file);
	}
	}

	// get Resource Specifier from XML file
	XMLInputSource in = new XMLInputSource(descriptor);
	ResourceSpecifier specifier = UIMAFramework.getXMLParser().parseResourceSpecifier(in);

	// create Analysis Engine
	AnalysisEngine ae = UIMAFramework.produceAnalysisEngine(specifier);

	// create a CAS
	CAS cas = ae.newCAS();

	// Create a file filter depending on the format
	// to filter out all file which do not have the
	// expected file ending
	FileFilter fileFilter;
	if (InputFormat.CAS.equals(inputFormat)) {
	fileFilter = new FileFilter() {

	public boolean accept(File file) {
	return file.getName().endsWith(".xmi") \|\| file.getName().endsWith(".xcas") \|\|
	(inputRecursive && file.isDirectory());
	}
	};
	}
	else if (InputFormat.PLAIN_TEXT.equals(inputFormat)) {
	fileFilter = new FileFilter() {

	public boolean accept(File file) {
	return file.getName().endsWith(".txt") \|\| (inputRecursive && file.isDirectory());
	}
	};
	}
	else {
	throw new IllegalStateException("Unexpected input format!");
	}

	findAndProcessFiles(inputResource, fileFilter, ae, cas);

	ae.collectionProcessComplete(new ProcessTrace_impl());
	ae.destroy();
	}
	}