/* | |
* 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.ruta.ide.launching; | |
import java.io.File; | |
import java.io.FileInputStream; | |
import java.io.FileOutputStream; | |
import java.io.IOException; | |
import java.util.ArrayList; | |
import java.util.List; | |
import java.util.logging.Handler; | |
import java.util.logging.LogRecord; | |
import java.util.logging.Logger; | |
import org.apache.uima.UIMAFramework; | |
import org.apache.uima.analysis_engine.AnalysisEngine; | |
import org.apache.uima.cas.CAS; | |
import org.apache.uima.cas.impl.XmiCasDeserializer; | |
import org.apache.uima.cas.impl.XmiCasSerializer; | |
import org.apache.uima.resource.ResourceManager; | |
import org.apache.uima.resource.ResourceSpecifier; | |
import org.apache.uima.ruta.action.LogAction; | |
import org.apache.uima.ruta.engine.RutaEngine; | |
import org.apache.uima.ruta.ide.RutaIdeUIPlugin; | |
import org.apache.uima.ruta.ide.core.RutaCorePreferences; | |
import org.apache.uima.ruta.ide.core.builder.RutaProjectUtils; | |
import org.apache.uima.util.XMLInputSource; | |
import org.apache.uima.util.XMLSerializer; | |
import org.eclipse.core.resources.IFolder; | |
import org.eclipse.core.resources.IResource; | |
import org.eclipse.core.runtime.CoreException; | |
import org.eclipse.core.runtime.IPath; | |
import org.eclipse.core.runtime.IProgressMonitor; | |
import org.eclipse.core.runtime.IStatus; | |
import org.eclipse.core.runtime.NullProgressMonitor; | |
import org.eclipse.core.runtime.Status; | |
import org.eclipse.core.runtime.SubProgressMonitor; | |
import org.eclipse.debug.core.ILaunch; | |
import org.eclipse.dltk.core.DLTKCore; | |
import org.eclipse.dltk.core.IScriptProject; | |
import org.eclipse.dltk.launching.AbstractInterpreterRunner; | |
import org.eclipse.dltk.launching.AbstractScriptLaunchConfigurationDelegate; | |
import org.eclipse.dltk.launching.IInterpreterInstall; | |
import org.eclipse.dltk.launching.InterpreterConfig; | |
import org.eclipse.dltk.launching.ScriptLaunchConfigurationConstants; | |
import org.eclipse.jdt.core.IJavaProject; | |
import org.eclipse.jdt.launching.JavaRuntime; | |
import org.eclipse.jdt.launching.VMRunnerConfiguration; | |
import org.eclipse.jface.preference.IPreferenceStore; | |
import org.eclipse.ui.console.ConsolePlugin; | |
import org.eclipse.ui.console.IConsole; | |
import org.eclipse.ui.console.IConsoleManager; | |
import org.eclipse.ui.console.MessageConsole; | |
import org.eclipse.ui.console.MessageConsoleStream; | |
import org.xml.sax.SAXException; | |
public class RutaInterpreterRunner extends AbstractInterpreterRunner implements IConfigurableRunner { | |
public static final IRutaInterpreterRunnerConfig DEFAULT_CONFIG = new IRutaInterpreterRunnerConfig() { | |
public void adjustRunnerConfiguration(VMRunnerConfiguration vconfig, InterpreterConfig iconfig, | |
ILaunch launch, IJavaProject project) { | |
System.out.println("adjust runner"); | |
} | |
public String[] computeClassPath(InterpreterConfig config, ILaunch launch, IJavaProject project) | |
throws Exception { | |
return RutaInterpreterRunner.getClassPath(project); | |
} | |
public String[] getProgramArguments(InterpreterConfig config, ILaunch launch, | |
IJavaProject project) { | |
return new String[0]; | |
} | |
public String getRunnerClassName(InterpreterConfig config, ILaunch launch, IJavaProject project) { | |
return "RutaRunner"; | |
} | |
}; | |
private IRutaInterpreterRunnerConfig config = DEFAULT_CONFIG; | |
@Override | |
public void run(InterpreterConfig config, ILaunch launch, IProgressMonitor monitor) | |
throws CoreException { | |
doRunImpl(config, launch, this.config, monitor); | |
} | |
private static Handler initConsoleLink(String module) { | |
final MessageConsole console; | |
final MessageConsoleStream out; | |
console = findConsole(module); | |
out = console.newMessageStream(); | |
Handler handler = new Handler() { | |
@Override | |
public void publish(LogRecord record) { | |
String message = record.getMessage(); | |
if (message.equals("\\n")) { | |
out.println(); | |
} | |
String[] split = message.split("\\\\n"); | |
for (String string : split) { | |
out.println(string); | |
} | |
console.activate(); | |
} | |
@Override | |
public void flush() { | |
} | |
@Override | |
public void close() throws SecurityException { | |
} | |
}; | |
Logger.getLogger(LogAction.LOGGER_NAME).addHandler(handler); | |
return handler; | |
} | |
private static void clearConsoleLink(Handler handler) { | |
Logger.getLogger(LogAction.LOGGER_NAME).removeHandler(handler); | |
} | |
private static MessageConsole findConsole(String name) { | |
ConsolePlugin plugin = ConsolePlugin.getDefault(); | |
IConsoleManager conMan = plugin.getConsoleManager(); | |
IConsole[] existing = conMan.getConsoles(); | |
for (int i = 0; i < existing.length; i++) | |
if (name.equals(existing[i].getName())) | |
return (MessageConsole) existing[i]; | |
MessageConsole myConsole = new MessageConsole(name, null); | |
conMan.addConsoles(new IConsole[] { myConsole }); | |
return myConsole; | |
} | |
public static List<File> getFiles(File dir, boolean recusive) { | |
List<File> result = new ArrayList<File>(); | |
for (File each : dir.listFiles()) { | |
// TODO: find a solution for this hotfix | |
if (each.getName().endsWith(".svn")) { | |
continue; | |
} | |
result.add(each); | |
if (each.isDirectory() && recusive) { | |
result.addAll(getFiles(each, recusive)); | |
} | |
} | |
return result; | |
} | |
public static void doRunImpl(InterpreterConfig config, ILaunch launch, | |
IRutaInterpreterRunnerConfig iconfig, IProgressMonitor monitor) throws CoreException { | |
String launchMode = launch.getLaunchMode(); | |
IScriptProject proj = AbstractScriptLaunchConfigurationDelegate.getScriptProject(launch | |
.getLaunchConfiguration()); | |
IPath projectPath = proj.getResource().getLocation(); | |
IPath inputDirPath = projectPath.append(RutaProjectUtils.getDefaultInputLocation()); | |
IPath outputDirPath = projectPath.append(RutaProjectUtils.getDefaultOutputLocation()); | |
String engine = RutaProjectUtils.getAnalysisEngineDescriptorPath(config.getScriptFilePath(), | |
proj.getProject()).toPortableString(); | |
IPath rootPath = RutaProjectUtils.getDescriptorRootPath(proj.getProject()); | |
File inputDir = inputDirPath.makeAbsolute().toFile(); | |
File outputDir = outputDirPath.makeAbsolute().toFile(); | |
if (!inputDir.exists()) { | |
inputDir.mkdirs(); | |
IFolder folder = proj.getProject().getFolder(RutaProjectUtils.getDefaultInputLocation()); | |
folder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); | |
} | |
IFolder outputFolder = proj.getProject().getFolder(RutaProjectUtils.getDefaultOutputLocation()); | |
if (!outputDir.exists()) { | |
outputDir.mkdirs(); | |
outputFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); | |
} | |
IPreferenceStore store = RutaIdeUIPlugin.getDefault().getPreferenceStore(); | |
boolean clearOutput = store.getBoolean(RutaCorePreferences.PROJECT_CLEAR_OUTPUT); | |
if (clearOutput) { | |
List<File> outputFiles = getFiles(outputDir, false); | |
for (File file : outputFiles) { | |
file.delete(); | |
} | |
outputFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); | |
} | |
List<File> inputFiles = getFiles(inputDir, false); | |
int ticks = (inputFiles.size() * 2) + 1; | |
SubProgressMonitor mon = new SubProgressMonitor(monitor, ticks); | |
mon.setTaskName("Initializing"); | |
Handler handler = initConsoleLink(config.getScriptFilePath().lastSegment()); | |
CAS cas = null; | |
AnalysisEngine ae = null; | |
try { | |
File specFile = new File(engine); | |
XMLInputSource in = new XMLInputSource(specFile); | |
ResourceSpecifier specifier = UIMAFramework.getXMLParser().parseResourceSpecifier(in); | |
ResourceManager resMgr = UIMAFramework.newDefaultResourceManager(); | |
resMgr.setDataPath(rootPath.toPortableString()); | |
ae = UIMAFramework.produceAnalysisEngine(specifier, resMgr, null); | |
} catch (Exception e) { | |
String message = e.getMessage(); | |
DLTKCore.error(message, e); | |
clearConsoleLink(handler); | |
throw new CoreException(new Status(IStatus.ERROR, RutaIdeUIPlugin.PLUGIN_ID, | |
ScriptLaunchConfigurationConstants.ERR_INTERNAL_ERROR, message, e)); | |
} | |
try { | |
if ("debug".equals(launchMode)) { | |
ae.setConfigParameterValue(RutaEngine.PARAM_DEBUG, true); | |
ae.setConfigParameterValue(RutaEngine.PARAM_DEBUG_WITH_MATCHES, true); | |
ae.setConfigParameterValue(RutaEngine.PARAM_PROFILE, true); | |
ae.setConfigParameterValue(RutaEngine.PARAM_STATISTICS, true); | |
ae.setConfigParameterValue(RutaEngine.PARAM_CREATED_BY, true); | |
ae.reconfigure(); | |
} | |
} catch (Exception e) { | |
clearConsoleLink(handler); | |
String message = e.getMessage(); | |
DLTKCore.error(message, e); | |
throw new CoreException(new Status(IStatus.ERROR, RutaIdeUIPlugin.PLUGIN_ID, | |
ScriptLaunchConfigurationConstants.ERR_INTERNAL_ERROR, message, e)); | |
} | |
mon.worked(1); | |
for (File each : inputFiles) { | |
mon.setTaskName("Processing " + each.getName()); | |
if (mon.isCanceled()) { | |
break; | |
} | |
try { | |
if (cas == null) { | |
cas = ae.newCAS(); | |
} else { | |
cas.reset(); | |
} | |
if (each.getName().endsWith("xmi")) { | |
XmiCasDeserializer.deserialize(new FileInputStream(each), cas, true); | |
} else { | |
cas.setDocumentText(getText(each)); | |
} | |
if (mon.isCanceled()) { | |
break; | |
} | |
RutaEngine.removeSourceDocumentInformation(cas); | |
RutaEngine.addSourceDocumentInformation(cas, each); | |
ae.process(cas); | |
mon.worked(1); | |
if (mon.isCanceled()) { | |
break; | |
} | |
File outputFile = new File(outputDir, each.getName() + ".xmi"); | |
mon.setTaskName("Saving " + outputFile.getName()); | |
writeXmi(cas, outputFile); | |
mon.worked(1); | |
} catch (Exception e) { | |
if (cas != null) { | |
cas.release(); | |
} | |
if (ae != null) { | |
ae.destroy(); | |
} | |
clearConsoleLink(handler); | |
String message = e.getMessage(); | |
DLTKCore.error(message, e); | |
throw new CoreException(new Status(IStatus.ERROR, RutaIdeUIPlugin.PLUGIN_ID, | |
ScriptLaunchConfigurationConstants.ERR_INTERNAL_ERROR, message, e)); | |
} | |
} | |
if (cas != null) { | |
cas.release(); | |
} | |
if (ae != null) { | |
ae.destroy(); | |
} | |
IFolder folder = outputFolder; | |
folder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); | |
clearConsoleLink(handler); | |
mon.done(); | |
} | |
private static String getText(File each) { | |
try { | |
return org.apache.uima.pear.util.FileUtil.loadTextFile(each, "UTF-8"); | |
} catch (IOException e) { | |
DLTKCore.error(e.getMessage(), e); | |
} | |
return ""; | |
} | |
private static void writeXmi(CAS aCas, File name) throws IOException, SAXException { | |
FileOutputStream out = null; | |
try { | |
// write XMI | |
out = new FileOutputStream(name); | |
XmiCasSerializer ser = new XmiCasSerializer(aCas.getTypeSystem()); | |
XMLSerializer xmlSer = new XMLSerializer(out, false); | |
ser.serialize(aCas, xmlSer.getContentHandler()); | |
} finally { | |
if (out != null) { | |
out.close(); | |
} | |
} | |
} | |
public static String[] getClassPath(IJavaProject myJavaProject) { | |
String[] newClassPath = new String[0];// classPath.length + 2]; | |
return newClassPath; | |
} | |
protected static String[] computeBaseClassPath(IJavaProject myJavaProject) throws CoreException { | |
if (!myJavaProject.exists()) | |
return new String[0]; | |
return JavaRuntime.computeDefaultRuntimeClassPath(myJavaProject); | |
} | |
protected String constructProgramString(InterpreterConfig config) { | |
return ""; | |
} | |
public RutaInterpreterRunner(IInterpreterInstall install) { | |
super(install); | |
} | |
@Override | |
protected String getProcessType() { | |
return RutaLaunchConfigurationConstants.ID_RUTA_PROCESS_TYPE; | |
} | |
public void setRunnerConfig(IRutaInterpreterRunnerConfig config) { | |
this.config = config; | |
} | |
} |