gerrit-server/src/main/java/com/google/gerrit/rules/PrologCompiler.java - gerrit.git - Git at Google

 // Copyright (C) 2011 The Android Open Source Project
 //
 // Licensed 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 com.google.gerrit.rules;

 import com.google.gerrit.common.Version;
 import com.google.gerrit.server.config.GerritServerConfig;
 import com.google.gerrit.server.config.SitePaths;
 import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.inject.Inject;
 import com.google.inject.assistedinject.Assisted;

 import com.googlecode.prolog_cafe.compiler.CompileException;
 import com.googlecode.prolog_cafe.compiler.Compiler;

 import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.lib.Config;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Repository;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.concurrent.Callable;
 import java.util.jar.Attributes;
 import java.util.jar.JarEntry;
 import java.util.jar.JarOutputStream;
 import java.util.jar.Manifest;

 import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;

 /**
  * Helper class for Rulec: does the actual prolog -> java src -> class -> jar work
  * Finds rules.pl in refs/meta/config branch
  * Creates rules-(sha1 of rules.pl).jar in (site-path)/cache/rules
  */
 public class PrologCompiler implements Callable<PrologCompiler.Status> {
   public interface Factory {
     PrologCompiler create(Repository git);
   }

   public static enum Status {
     NO_RULES, COMPILED;
   }

   private final File ruleDir;
   private final Repository git;

   @Inject
   PrologCompiler(@GerritServerConfig Config config, SitePaths site,
       @Assisted Repository gitRepository) {
     File cacheDir = site.resolve(config.getString("cache", null, "directory"));
     ruleDir = cacheDir != null ? new File(cacheDir, "rules") : null;
     git = gitRepository;
   }

   public Status call() throws IOException, CompileException {
     ObjectId metaConfig = git.resolve(GitRepositoryManager.REF_CONFIG);
     if (metaConfig == null) {
       return Status.NO_RULES;
     }

     ObjectId rulesId = git.resolve(metaConfig.name() + ":rules.pl");
     if (rulesId == null) {
       return Status.NO_RULES;
     }

     if (ruleDir == null) {
       throw new CompileException("Caching not enabled");
     }
     if (!ruleDir.isDirectory() && !ruleDir.mkdir()) {
       throw new IOException("Cannot create " + ruleDir);
     }

     File tempDir = File.createTempFile("GerritCodeReview_", ".rulec");
     if (!tempDir.delete() || !tempDir.mkdir()) {
       throw new IOException("Cannot create " + tempDir);
     }
     try {
       // Try to make the directory accessible only by this process.
       // This may help to prevent leaking rule data to outsiders.
       tempDir.setReadable(true, true);
       tempDir.setWritable(true, true);
       tempDir.setExecutable(true, true);

       compileProlog(rulesId, tempDir);
       compileJava(tempDir);

       File jarFile = new File(ruleDir, "rules-" + rulesId.getName() + ".jar");
       List<String> classFiles = getRelativePaths(tempDir, ".class");
       createJar(jarFile, classFiles, tempDir, metaConfig, rulesId);

       return Status.COMPILED;
     } finally {
       deleteAllFiles(tempDir);
     }
   }

   /** Creates a copy of rules.pl and compiles it into Java sources. */
   private void compileProlog(ObjectId prolog, File tempDir)
       throws IOException, CompileException {
     File tempRules = copyToTempFile(prolog, tempDir);
     try {
       Compiler comp = new Compiler();
       comp.prologToJavaSource(tempRules.getPath(), tempDir.getPath());
     } finally {
       tempRules.delete();
     }
   }

   private File copyToTempFile(ObjectId blobId, File tempDir)
       throws IOException, FileNotFoundException, MissingObjectException {
     // Any leak of tmp caused by this method failing will be cleaned
     // up by our caller when tempDir is recursively deleted.
     File tmp = File.createTempFile("rules", ".pl", tempDir);
     FileOutputStream out = new FileOutputStream(tmp);
     try {
       git.open(blobId).copyTo(out);
     } finally {
       out.close();
     }
     return tmp;
   }

   /** Compile java src into java .class files */
   private void compileJava(File tempDir) throws IOException, CompileException {
     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
     if (compiler == null) {
       throw new CompileException("JDK required (running inside of JRE)");
     }

     DiagnosticCollector<JavaFileObject> diagnostics =
         new DiagnosticCollector<JavaFileObject>();
     StandardJavaFileManager fileManager =
         compiler.getStandardFileManager(diagnostics, null, null);
     try {
       Iterable<? extends JavaFileObject> compilationUnits = fileManager
         .getJavaFileObjectsFromFiles(getAllFiles(tempDir, ".java"));
       ArrayList<String> options = new ArrayList<String>();
       String classpath = getMyClasspath();
       if (classpath != null) {
         options.add("-classpath");
         options.add(classpath);
       }
       options.add("-d");
       options.add(tempDir.getPath());
       JavaCompiler.CompilationTask task = compiler.getTask(
           null,
           fileManager,
           diagnostics,
           options,
           null,
           compilationUnits);
       if (!task.call()) {
         Locale myLocale = Locale.getDefault();
         StringBuilder msg = new StringBuilder();
         msg.append("Cannot compile to Java bytecode:");
         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(myLocale));
         }
         throw new CompileException(msg.toString());
       }
     } finally {
       fileManager.close();
     }
   }

   private String getMyClasspath() {
     StringBuilder cp = new StringBuilder();
     appendClasspath(cp, getClass().getClassLoader());
     return 0 < cp.length() ? cp.toString() : null;
   }

   private void appendClasspath(StringBuilder cp, ClassLoader classLoader) {
     if (classLoader.getParent() != null) {
       appendClasspath(cp, classLoader.getParent());
     }
     if (classLoader instanceof URLClassLoader) {
       for (URL url : ((URLClassLoader) classLoader).getURLs()) {
         if ("file".equals(url.getProtocol())) {
           if (0 < cp.length()) {
             cp.append(File.pathSeparatorChar);
           }
           cp.append(url.getPath());
         }
       }
     }
   }

   /** Takes compiled prolog .class files, puts them into the jar file. */
   private void createJar(File archiveFile, List<String> toBeJared,
       File tempDir, ObjectId metaConfig, ObjectId rulesId) throws IOException {
     long now = System.currentTimeMillis();
     File tmpjar = File.createTempFile(".rulec_", ".jar", archiveFile.getParentFile());
     try {
       Manifest mf = new Manifest();
       mf.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
       mf.getMainAttributes().putValue("Built-by", "Gerrit Code Review " + Version.getVersion());
       if (git.getDirectory() != null) {
         mf.getMainAttributes().putValue("Source-Repository", git.getDirectory().getPath());
       }
       mf.getMainAttributes().putValue("Source-Commit", metaConfig.name());
       mf.getMainAttributes().putValue("Source-Blob", rulesId.name());

       FileOutputStream stream = new FileOutputStream(tmpjar);
       JarOutputStream out = new JarOutputStream(stream, mf);
       byte buffer[] = new byte[10240];
       try {
         for (String path : toBeJared) {
           JarEntry jarAdd = new JarEntry(path);
           File f = new File(tempDir, path);
           jarAdd.setTime(now);
           out.putNextEntry(jarAdd);
           if (f.isFile()) {
             FileInputStream in = new FileInputStream(f);
             try {
               while (true) {
                 int nRead = in.read(buffer, 0, buffer.length);
                 if (nRead <= 0) {
                   break;
                 }
                 out.write(buffer, 0, nRead);
               }
             } finally {
               in.close();
             }
           }
           out.closeEntry();
         }
       } finally {
         out.close();
       }

       if (!tmpjar.renameTo(archiveFile)) {
         throw new IOException("Cannot replace " + archiveFile);
       }
     } finally {
       tmpjar.delete();
     }
   }

   private List<File> getAllFiles(File dir, String extension) {
     ArrayList<File> fileList = new ArrayList<File>();
     getAllFiles(dir, extension, fileList);
     return fileList;
   }

   private void getAllFiles(File dir, String extension, List<File> fileList) {
     for (File f : dir.listFiles()) {
       if (f.getName().endsWith(extension)) {
         fileList.add(f);
       }
       if (f.isDirectory()) {
         getAllFiles(f, extension, fileList);
       }
     }
   }

   private List<String> getRelativePaths(File dir, String extension) {
     ArrayList<String> pathList = new ArrayList<String>();
     getRelativePaths(dir, extension, "", pathList);
     return pathList;
   }

   private void getRelativePaths(File dir, String extension, String path, List<String> pathList) {
     for (File f : dir.listFiles()) {
       if (f.getName().endsWith(extension)) {
         pathList.add(path + f.getName());
       }
       if (f.isDirectory()) {
         getRelativePaths(f, extension, path + f.getName() + "/", pathList);
       }
     }
   }

   private void deleteAllFiles(File dir) {
     for (File f : dir.listFiles()) {
       if (f.isDirectory()) {
         deleteAllFiles(f);
       } else {
         f.delete();
       }
     }
     dir.delete();
   }
 }
	// Copyright (C) 2011 The Android Open Source Project
	//
	// Licensed 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 com.google.gerrit.rules;

	import com.google.gerrit.common.Version;
	import com.google.gerrit.server.config.GerritServerConfig;
	import com.google.gerrit.server.config.SitePaths;
	import com.google.gerrit.server.git.GitRepositoryManager;
	import com.google.inject.Inject;
	import com.google.inject.assistedinject.Assisted;

	import com.googlecode.prolog_cafe.compiler.CompileException;
	import com.googlecode.prolog_cafe.compiler.Compiler;

	import org.eclipse.jgit.errors.MissingObjectException;
	import org.eclipse.jgit.lib.Config;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.Repository;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.net.URL;
	import java.net.URLClassLoader;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Locale;
	import java.util.concurrent.Callable;
	import java.util.jar.Attributes;
	import java.util.jar.JarEntry;
	import java.util.jar.JarOutputStream;
	import java.util.jar.Manifest;

	import javax.tools.Diagnostic;
	import javax.tools.DiagnosticCollector;
	import javax.tools.JavaCompiler;
	import javax.tools.JavaFileObject;
	import javax.tools.StandardJavaFileManager;
	import javax.tools.ToolProvider;

	/**
	* Helper class for Rulec: does the actual prolog -> java src -> class -> jar work
	* Finds rules.pl in refs/meta/config branch
	* Creates rules-(sha1 of rules.pl).jar in (site-path)/cache/rules
	*/
	public class PrologCompiler implements Callable<PrologCompiler.Status> {
	public interface Factory {
	PrologCompiler create(Repository git);
	}

	public static enum Status {
	NO_RULES, COMPILED;
	}

	private final File ruleDir;
	private final Repository git;

	@Inject
	PrologCompiler(@GerritServerConfig Config config, SitePaths site,
	@Assisted Repository gitRepository) {
	File cacheDir = site.resolve(config.getString("cache", null, "directory"));
	ruleDir = cacheDir != null ? new File(cacheDir, "rules") : null;
	git = gitRepository;
	}

	public Status call() throws IOException, CompileException {
	ObjectId metaConfig = git.resolve(GitRepositoryManager.REF_CONFIG);
	if (metaConfig == null) {
	return Status.NO_RULES;
	}

	ObjectId rulesId = git.resolve(metaConfig.name() + ":rules.pl");
	if (rulesId == null) {
	return Status.NO_RULES;
	}

	if (ruleDir == null) {
	throw new CompileException("Caching not enabled");
	}
	if (!ruleDir.isDirectory() && !ruleDir.mkdir()) {
	throw new IOException("Cannot create " + ruleDir);
	}

	File tempDir = File.createTempFile("GerritCodeReview_", ".rulec");
	if (!tempDir.delete() \|\| !tempDir.mkdir()) {
	throw new IOException("Cannot create " + tempDir);
	}
	try {
	// Try to make the directory accessible only by this process.
	// This may help to prevent leaking rule data to outsiders.
	tempDir.setReadable(true, true);
	tempDir.setWritable(true, true);
	tempDir.setExecutable(true, true);

	compileProlog(rulesId, tempDir);
	compileJava(tempDir);

	File jarFile = new File(ruleDir, "rules-" + rulesId.getName() + ".jar");
	List<String> classFiles = getRelativePaths(tempDir, ".class");
	createJar(jarFile, classFiles, tempDir, metaConfig, rulesId);

	return Status.COMPILED;
	} finally {
	deleteAllFiles(tempDir);
	}
	}

	/** Creates a copy of rules.pl and compiles it into Java sources. */
	private void compileProlog(ObjectId prolog, File tempDir)
	throws IOException, CompileException {
	File tempRules = copyToTempFile(prolog, tempDir);
	try {
	Compiler comp = new Compiler();
	comp.prologToJavaSource(tempRules.getPath(), tempDir.getPath());
	} finally {
	tempRules.delete();
	}
	}

	private File copyToTempFile(ObjectId blobId, File tempDir)
	throws IOException, FileNotFoundException, MissingObjectException {
	// Any leak of tmp caused by this method failing will be cleaned
	// up by our caller when tempDir is recursively deleted.
	File tmp = File.createTempFile("rules", ".pl", tempDir);
	FileOutputStream out = new FileOutputStream(tmp);
	try {
	git.open(blobId).copyTo(out);
	} finally {
	out.close();
	}
	return tmp;
	}

	/** Compile java src into java .class files */
	private void compileJava(File tempDir) throws IOException, CompileException {
	JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
	if (compiler == null) {
	throw new CompileException("JDK required (running inside of JRE)");
	}

	DiagnosticCollector<JavaFileObject> diagnostics =
	new DiagnosticCollector<JavaFileObject>();
	StandardJavaFileManager fileManager =
	compiler.getStandardFileManager(diagnostics, null, null);
	try {
	Iterable<? extends JavaFileObject> compilationUnits = fileManager
	.getJavaFileObjectsFromFiles(getAllFiles(tempDir, ".java"));
	ArrayList<String> options = new ArrayList<String>();
	String classpath = getMyClasspath();
	if (classpath != null) {
	options.add("-classpath");
	options.add(classpath);
	}
	options.add("-d");
	options.add(tempDir.getPath());
	JavaCompiler.CompilationTask task = compiler.getTask(
	null,
	fileManager,
	diagnostics,
	options,
	null,
	compilationUnits);
	if (!task.call()) {
	Locale myLocale = Locale.getDefault();
	StringBuilder msg = new StringBuilder();
	msg.append("Cannot compile to Java bytecode:");
	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(myLocale));
	}
	throw new CompileException(msg.toString());
	}
	} finally {
	fileManager.close();
	}
	}

	private String getMyClasspath() {
	StringBuilder cp = new StringBuilder();
	appendClasspath(cp, getClass().getClassLoader());
	return 0 < cp.length() ? cp.toString() : null;
	}

	private void appendClasspath(StringBuilder cp, ClassLoader classLoader) {
	if (classLoader.getParent() != null) {
	appendClasspath(cp, classLoader.getParent());
	}
	if (classLoader instanceof URLClassLoader) {
	for (URL url : ((URLClassLoader) classLoader).getURLs()) {
	if ("file".equals(url.getProtocol())) {
	if (0 < cp.length()) {
	cp.append(File.pathSeparatorChar);
	}
	cp.append(url.getPath());
	}
	}
	}
	}

	/** Takes compiled prolog .class files, puts them into the jar file. */
	private void createJar(File archiveFile, List<String> toBeJared,
	File tempDir, ObjectId metaConfig, ObjectId rulesId) throws IOException {
	long now = System.currentTimeMillis();
	File tmpjar = File.createTempFile(".rulec_", ".jar", archiveFile.getParentFile());
	try {
	Manifest mf = new Manifest();
	mf.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
	mf.getMainAttributes().putValue("Built-by", "Gerrit Code Review " + Version.getVersion());
	if (git.getDirectory() != null) {
	mf.getMainAttributes().putValue("Source-Repository", git.getDirectory().getPath());
	}
	mf.getMainAttributes().putValue("Source-Commit", metaConfig.name());
	mf.getMainAttributes().putValue("Source-Blob", rulesId.name());

	FileOutputStream stream = new FileOutputStream(tmpjar);
	JarOutputStream out = new JarOutputStream(stream, mf);
	byte buffer[] = new byte[10240];
	try {
	for (String path : toBeJared) {
	JarEntry jarAdd = new JarEntry(path);
	File f = new File(tempDir, path);
	jarAdd.setTime(now);
	out.putNextEntry(jarAdd);
	if (f.isFile()) {
	FileInputStream in = new FileInputStream(f);
	try {
	while (true) {
	int nRead = in.read(buffer, 0, buffer.length);
	if (nRead <= 0) {
	break;
	}
	out.write(buffer, 0, nRead);
	}
	} finally {
	in.close();
	}
	}
	out.closeEntry();
	}
	} finally {
	out.close();
	}

	if (!tmpjar.renameTo(archiveFile)) {
	throw new IOException("Cannot replace " + archiveFile);
	}
	} finally {
	tmpjar.delete();
	}
	}

	private List<File> getAllFiles(File dir, String extension) {
	ArrayList<File> fileList = new ArrayList<File>();
	getAllFiles(dir, extension, fileList);
	return fileList;
	}

	private void getAllFiles(File dir, String extension, List<File> fileList) {
	for (File f : dir.listFiles()) {
	if (f.getName().endsWith(extension)) {
	fileList.add(f);
	}
	if (f.isDirectory()) {
	getAllFiles(f, extension, fileList);
	}
	}
	}

	private List<String> getRelativePaths(File dir, String extension) {
	ArrayList<String> pathList = new ArrayList<String>();
	getRelativePaths(dir, extension, "", pathList);
	return pathList;
	}

	private void getRelativePaths(File dir, String extension, String path, List<String> pathList) {
	for (File f : dir.listFiles()) {
	if (f.getName().endsWith(extension)) {
	pathList.add(path + f.getName());
	}
	if (f.isDirectory()) {
	getRelativePaths(f, extension, path + f.getName() + "/", pathList);
	}
	}
	}

	private void deleteAllFiles(File dir) {
	for (File f : dir.listFiles()) {
	if (f.isDirectory()) {
	deleteAllFiles(f);
	} else {
	f.delete();
	}
	}
	dir.delete();
	}
	}