/*
|
Dateiverwaltung - File management in your browser
|
Copyright (C) 2017 Ulrich Hilger, http://uhilger.de
|
|
This program is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as
|
published by the Free Software Foundation, either version 3 of the
|
License, or (at your option) any later version.
|
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
package de.uhilger.filecms.api;
|
|
import static de.uhilger.filecms.api.FileMgr.HOME_DIR_NAME;
|
import static de.uhilger.filecms.api.FileMgr.HOME_DIR_PATH;
|
import static de.uhilger.filecms.api.FileMgr.PUB_DIR_NAME;
|
import static de.uhilger.filecms.api.FileMgr.PUB_DIR_PATH;
|
import de.uhilger.filecms.data.FileRef;
|
import de.uhilger.filecms.web.Initialiser;
|
import de.uhilger.transit.web.RequestKontext;
|
import de.uhilger.transit.web.WebKontext;
|
import java.io.File;
|
import java.io.IOException;
|
import java.security.Principal;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.logging.Logger;
|
import javax.servlet.ServletContext;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.tools.Diagnostic;
|
import javax.tools.DiagnosticCollector;
|
import javax.tools.JavaCompiler;
|
import javax.tools.JavaFileObject;
|
import javax.tools.StandardJavaFileManager;
|
import javax.tools.ToolProvider;
|
import org.apache.commons.io.FileUtils;
|
|
/**
|
*
|
*/
|
public class CompileService implements RequestKontext, WebKontext {
|
|
private static final Logger logger = Logger.getLogger(CompileService.class.getName());
|
|
private ServletContext ctx;
|
private HttpServletRequest request;
|
|
public String compile(String relPath, List fileNames) throws IOException {
|
//Files[] files1 = ... ; // input for first compilation task
|
//Files[] files2 = ... ; // input for second compilation task
|
|
File targetDir = getTargetDir(relPath);
|
//System.out.println(targetDir.getAbsolutePath());
|
ArrayList<File> files = new ArrayList();
|
|
for(int i=0; i < fileNames.size(); i++) {
|
Object o = fileNames.get(i);
|
if(o instanceof ArrayList) {
|
ArrayList al = (ArrayList) o;
|
logger.fine(al.get(0).toString());
|
File targetFile = new File(targetDir, al.get(0).toString());
|
logger.fine(targetFile.getAbsolutePath());
|
files.add(targetFile);
|
}
|
}
|
|
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
|
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector();
|
StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);
|
|
Iterable<? extends JavaFileObject> compilationUnits1 = fileManager.getJavaFileObjectsFromFiles(files);
|
|
final Iterable<String> options =
|
Arrays.asList(new String[]{"-Xlint",
|
/*"-cp", project.getClassPath(),*/
|
"-d", targetDir.getAbsolutePath()
|
});
|
|
compiler.getTask(null, fileManager, diagnostics, options, null, compilationUnits1).call();
|
|
/*
|
Iterable<? extends JavaFileObject> compilationUnits2
|
= fileManager.getJavaFileObjects(files2); // use alternative method
|
// reuse the same file manager to allow caching of jar files
|
compiler.getTask(null, fileManager, null, null, null, compilationUnits2).call();
|
*/
|
fileManager.close();
|
|
StringBuilder msg = new StringBuilder();
|
msg.append("Result of compile to Java bytecode (empty means no error):");
|
for (Diagnostic<? extends JavaFileObject> err : diagnostics.getDiagnostics()) {
|
msg.append('\n');
|
msg.append(err.getKind());
|
msg.append(": ");
|
if (err.getSource() != null) {
|
msg.append(err.getSource().getName());
|
}
|
msg.append(':');
|
msg.append(err.getLineNumber());
|
msg.append(": ");
|
msg.append(err.getMessage(Locale.GERMANY));
|
}
|
|
return msg.toString();
|
}
|
private File getTargetDir(String relPath) {
|
logger.fine(relPath);
|
String targetPath = null;
|
if(relPath.startsWith(PUB_DIR_NAME)) {
|
targetPath = PUB_DIR_PATH + getUserName() + relPath.substring(PUB_DIR_NAME.length());
|
} else if(relPath.startsWith(HOME_DIR_NAME)) {
|
targetPath = HOME_DIR_PATH + getUserName() + relPath.substring(HOME_DIR_NAME.length());
|
} else {
|
// kann eigentlich nicht sein..
|
}
|
logger.fine(targetPath);
|
File targetDir = new File(getBase().getAbsolutePath(), targetPath);
|
return targetDir;
|
}
|
|
private FileRef getBase() {
|
FileRef base = null;
|
Object o = getServletContext().getAttribute(Initialiser.FILE_BASE);
|
if(o instanceof String) {
|
String baseStr = (String) o;
|
logger.fine(baseStr);
|
File file = new File(baseStr);
|
base = new FileRef(file.getAbsolutePath(), file.isDirectory());
|
}
|
return base;
|
}
|
private String getUserName() {
|
String userName = null;
|
Object p = getRequest().getUserPrincipal();
|
if(p instanceof Principal) {
|
userName = ((Principal) p).getName();
|
}
|
return userName;
|
}
|
|
@Override
|
public HttpServletRequest getRequest() {
|
return request;
|
}
|
|
@Override
|
public void setRequest(HttpServletRequest r) {
|
this.request = r;
|
}
|
|
@Override
|
public ServletContext getServletContext() {
|
return ctx;
|
}
|
|
@Override
|
public void setServletContext(ServletContext servletContext) {
|
this.ctx = servletContext;
|
}
|
}
|
|
|
/*
|
|
Beispeil fuer einen dynamischen Compiler-Aufruf
|
'in memory'
|
|
String className = "mypackage.MyClass";
|
String javaCode = "package mypackage;\n" +
|
"public class MyClass implements Runnable {\n" +
|
" public void run() {\n" +
|
" System.out.println("\"Hello World\");\n" +
|
" }\n" +
|
"}\n";
|
Class aClass = CompilerUtils.CACHED_COMPILER.loadFromJava(className, javaCode);
|
Runnable runner = (Runnable) aClass.newInstance();
|
runner.run();
|
|
*/
|
