gerrit-server/src/main/java/com/google/gerrit/rules/RulesCache.java - gerrit - 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 static com.googlecode.prolog_cafe.lang.PrologMachineCopy.save;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.gerrit.extensions.registration.DynamicSet;
 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.reviewdb.client.RefNames;
 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.Singleton;

 import com.googlecode.prolog_cafe.compiler.CompileException;
 import com.googlecode.prolog_cafe.lang.BufferingPrologControl;
 import com.googlecode.prolog_cafe.lang.JavaObjectTerm;
 import com.googlecode.prolog_cafe.lang.Prolog;
 import com.googlecode.prolog_cafe.lang.PrologClassLoader;
 import com.googlecode.prolog_cafe.lang.PrologMachineCopy;
 import com.googlecode.prolog_cafe.lang.SymbolTerm;

 import org.eclipse.jgit.errors.LargeObjectException;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.lib.Config;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.util.RawParseUtils;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.PushbackReader;
 import java.io.Reader;
 import java.io.StringReader;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Manages a cache of compiled Prolog rules.
  * <p>
  * Rules are loaded from the {@code site_path/cache/rules/rules-SHA1.jar}, where
  * {@code SHA1} is the SHA1 of the Prolog {@code rules.pl} in a project's
  * {@link RefNames#REFS_CONFIG} branch.
  */
 @Singleton
 public class RulesCache {
   /** Maximum size of a dynamic Prolog script, in bytes. */
   private static final int SRC_LIMIT = 128 * 1024;

   /** Default size of the internal Prolog database within each interpreter. */
   private static final int DB_MAX = 256;

   private static final List<String> PACKAGE_LIST = ImmutableList.of(
       Prolog.BUILTIN, "gerrit");

   private final Map<ObjectId, MachineRef> machineCache = new HashMap<>();

   private final ReferenceQueue<PrologMachineCopy> dead =
       new ReferenceQueue<>();

   private static final class MachineRef extends WeakReference<PrologMachineCopy> {
     final ObjectId key;

     MachineRef(ObjectId key, PrologMachineCopy pcm,
         ReferenceQueue<PrologMachineCopy> queue) {
       super(pcm, queue);
       this.key = key;
     }
   }

   private final boolean enableProjectRules;
   private final File cacheDir;
   private final File rulesDir;
   private final GitRepositoryManager gitMgr;
   private final DynamicSet<PredicateProvider> predicateProviders;
   private final ClassLoader systemLoader;
   private final PrologMachineCopy defaultMachine;

   @Inject
   protected RulesCache(@GerritServerConfig Config config, SitePaths site,
       GitRepositoryManager gm, DynamicSet<PredicateProvider> predicateProviders) {
     enableProjectRules = config.getBoolean("rules", null, "enable", true);
     cacheDir = site.resolve(config.getString("cache", null, "directory"));
     rulesDir = cacheDir != null ? new File(cacheDir, "rules") : null;
     gitMgr = gm;
     this.predicateProviders = predicateProviders;

     systemLoader = getClass().getClassLoader();
     defaultMachine = save(newEmptyMachine(systemLoader));
   }

   public boolean isProjectRulesEnabled() {
     return enableProjectRules;
   }

   /**
    * Locate a cached Prolog machine state, or create one if not available.
    *
    * @return a Prolog machine, after loading the specified rules.
    * @throws CompileException the machine cannot be created.
    */
   public synchronized PrologMachineCopy loadMachine(
       Project.NameKey project,
       ObjectId rulesId)
       throws CompileException {
     if (!enableProjectRules || project == null || rulesId == null) {
       return defaultMachine;
     }

     Reference<? extends PrologMachineCopy> ref = machineCache.get(rulesId);
     if (ref != null) {
       PrologMachineCopy pmc = ref.get();
       if (pmc != null) {
         return pmc;
       }

       machineCache.remove(rulesId);
       ref.enqueue();
     }

     gc();

     PrologMachineCopy pcm = createMachine(project, rulesId);
     MachineRef newRef = new MachineRef(rulesId, pcm, dead);
     machineCache.put(rulesId, newRef);
     return pcm;
   }

   public PrologMachineCopy loadMachine(String name, InputStream in)
       throws CompileException {
     PrologMachineCopy pmc = consultRules(name, new InputStreamReader(in));
     if (pmc == null) {
       throw new CompileException("Cannot consult rules from the stream " + name);
     }
     return pmc;
   }

   private void gc() {
     Reference<?> ref;
     while ((ref = dead.poll()) != null) {
       ObjectId key = ((MachineRef) ref).key;
       if (machineCache.get(key) == ref) {
         machineCache.remove(key);
       }
     }
   }

   private PrologMachineCopy createMachine(Project.NameKey project,
       ObjectId rulesId) throws CompileException {
     // If the rules are available as a complied JAR on local disk, prefer
     // that over dynamic consult as the bytecode will be faster.
     //
     if (rulesDir != null) {
       File jarFile = new File(rulesDir, "rules-" + rulesId.getName() + ".jar");
       if (jarFile.isFile()) {
         URL[] cp = new URL[] {toURL(jarFile)};
         return save(newEmptyMachine(new URLClassLoader(cp, systemLoader)));
       }
     }

     // Dynamically consult the rules into the machine's internal database.
     //
     String rules = read(project, rulesId);
     PrologMachineCopy pmc = consultRules("rules.pl", new StringReader(rules));
     if (pmc == null) {
       throw new CompileException("Cannot consult rules of " + project);
     }
     return pmc;
   }

   private PrologMachineCopy consultRules(String name, Reader rules)
       throws CompileException {
     BufferingPrologControl ctl = newEmptyMachine(systemLoader);
     PushbackReader in = new PushbackReader(rules, Prolog.PUSHBACK_SIZE);
     try {
       if (!ctl.execute(Prolog.BUILTIN, "consult_stream",
           SymbolTerm.intern(name), new JavaObjectTerm(in))) {
         return null;
       }
     } catch (RuntimeException e) {
       throw new CompileException("Error while consulting rules from " + name, e);
     }
     return save(ctl);
   }

   private String read(Project.NameKey project, ObjectId rulesId)
       throws CompileException {
     Repository git;
     try {
       git = gitMgr.openRepository(project);
     } catch (RepositoryNotFoundException e) {
       throw new CompileException("Cannot open repository " + project, e);
     } catch (IOException e) {
       throw new CompileException("Cannot open repository " + project, e);
     }
     try {
       ObjectLoader ldr = git.open(rulesId, Constants.OBJ_BLOB);
       byte[] raw = ldr.getCachedBytes(SRC_LIMIT);
       return RawParseUtils.decode(raw);
     } catch (LargeObjectException e) {
       throw new CompileException("rules of " + project + " are too large", e);
     } catch (RuntimeException e) {
       throw new CompileException("Cannot load rules of " + project, e);
     } catch (IOException e) {
       throw new CompileException("Cannot load rules of " + project, e);
     } finally {
       git.close();
     }
   }

   private BufferingPrologControl newEmptyMachine(ClassLoader cl) {
     BufferingPrologControl ctl = new BufferingPrologControl();
     ctl.setMaxArity(PrologEnvironment.MAX_ARITY);
     ctl.setMaxDatabaseSize(DB_MAX);
     ctl.setPrologClassLoader(new PrologClassLoader(new PredicateClassLoader(
         predicateProviders, cl)));
     ctl.setEnabled(EnumSet.allOf(Prolog.Feature.class), false);

     List<String> packages = Lists.newArrayList();
     packages.addAll(PACKAGE_LIST);
     for (PredicateProvider predicateProvider : predicateProviders) {
       packages.addAll(predicateProvider.getPackages());
     }

     // Bootstrap the interpreter and ensure there is clean state.
     ctl.initialize(packages.toArray(new String[packages.size()]));
     return ctl;
   }

   private static URL toURL(File jarFile) throws CompileException {
     try {
       return jarFile.toURI().toURL();
     } catch (MalformedURLException e) {
       throw new CompileException("Cannot create URL for " + jarFile, e);
     }
   }
 }
	// 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 static com.googlecode.prolog_cafe.lang.PrologMachineCopy.save;

	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.Lists;
	import com.google.gerrit.extensions.registration.DynamicSet;
	import com.google.gerrit.reviewdb.client.Project;
	import com.google.gerrit.reviewdb.client.RefNames;
	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.Singleton;

	import com.googlecode.prolog_cafe.compiler.CompileException;
	import com.googlecode.prolog_cafe.lang.BufferingPrologControl;
	import com.googlecode.prolog_cafe.lang.JavaObjectTerm;
	import com.googlecode.prolog_cafe.lang.Prolog;
	import com.googlecode.prolog_cafe.lang.PrologClassLoader;
	import com.googlecode.prolog_cafe.lang.PrologMachineCopy;
	import com.googlecode.prolog_cafe.lang.SymbolTerm;

	import org.eclipse.jgit.errors.LargeObjectException;
	import org.eclipse.jgit.errors.RepositoryNotFoundException;
	import org.eclipse.jgit.lib.Config;
	import org.eclipse.jgit.lib.Constants;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.ObjectLoader;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.util.RawParseUtils;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.PushbackReader;
	import java.io.Reader;
	import java.io.StringReader;
	import java.lang.ref.Reference;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.WeakReference;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.net.URLClassLoader;
	import java.util.EnumSet;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* Manages a cache of compiled Prolog rules.
	* <p>
	* Rules are loaded from the {@code site_path/cache/rules/rules-SHA1.jar}, where
	* {@code SHA1} is the SHA1 of the Prolog {@code rules.pl} in a project's
	* {@link RefNames#REFS_CONFIG} branch.
	*/
	@Singleton
	public class RulesCache {
	/** Maximum size of a dynamic Prolog script, in bytes. */
	private static final int SRC_LIMIT = 128 * 1024;

	/** Default size of the internal Prolog database within each interpreter. */
	private static final int DB_MAX = 256;

	private static final List<String> PACKAGE_LIST = ImmutableList.of(
	Prolog.BUILTIN, "gerrit");

	private final Map<ObjectId, MachineRef> machineCache = new HashMap<>();

	private final ReferenceQueue<PrologMachineCopy> dead =
	new ReferenceQueue<>();

	private static final class MachineRef extends WeakReference<PrologMachineCopy> {
	final ObjectId key;

	MachineRef(ObjectId key, PrologMachineCopy pcm,
	ReferenceQueue<PrologMachineCopy> queue) {
	super(pcm, queue);
	this.key = key;
	}
	}

	private final boolean enableProjectRules;
	private final File cacheDir;
	private final File rulesDir;
	private final GitRepositoryManager gitMgr;
	private final DynamicSet<PredicateProvider> predicateProviders;
	private final ClassLoader systemLoader;
	private final PrologMachineCopy defaultMachine;

	@Inject
	protected RulesCache(@GerritServerConfig Config config, SitePaths site,
	GitRepositoryManager gm, DynamicSet<PredicateProvider> predicateProviders) {
	enableProjectRules = config.getBoolean("rules", null, "enable", true);
	cacheDir = site.resolve(config.getString("cache", null, "directory"));
	rulesDir = cacheDir != null ? new File(cacheDir, "rules") : null;
	gitMgr = gm;
	this.predicateProviders = predicateProviders;

	systemLoader = getClass().getClassLoader();
	defaultMachine = save(newEmptyMachine(systemLoader));
	}

	public boolean isProjectRulesEnabled() {
	return enableProjectRules;
	}

	/**
	* Locate a cached Prolog machine state, or create one if not available.
	*
	* @return a Prolog machine, after loading the specified rules.
	* @throws CompileException the machine cannot be created.
	*/
	public synchronized PrologMachineCopy loadMachine(
	Project.NameKey project,
	ObjectId rulesId)
	throws CompileException {
	if (!enableProjectRules \|\| project == null \|\| rulesId == null) {
	return defaultMachine;
	}

	Reference<? extends PrologMachineCopy> ref = machineCache.get(rulesId);
	if (ref != null) {
	PrologMachineCopy pmc = ref.get();
	if (pmc != null) {
	return pmc;
	}

	machineCache.remove(rulesId);
	ref.enqueue();
	}

	gc();

	PrologMachineCopy pcm = createMachine(project, rulesId);
	MachineRef newRef = new MachineRef(rulesId, pcm, dead);
	machineCache.put(rulesId, newRef);
	return pcm;
	}

	public PrologMachineCopy loadMachine(String name, InputStream in)
	throws CompileException {
	PrologMachineCopy pmc = consultRules(name, new InputStreamReader(in));
	if (pmc == null) {
	throw new CompileException("Cannot consult rules from the stream " + name);
	}
	return pmc;
	}

	private void gc() {
	Reference<?> ref;
	while ((ref = dead.poll()) != null) {
	ObjectId key = ((MachineRef) ref).key;
	if (machineCache.get(key) == ref) {
	machineCache.remove(key);
	}
	}
	}

	private PrologMachineCopy createMachine(Project.NameKey project,
	ObjectId rulesId) throws CompileException {
	// If the rules are available as a complied JAR on local disk, prefer
	// that over dynamic consult as the bytecode will be faster.
	//
	if (rulesDir != null) {
	File jarFile = new File(rulesDir, "rules-" + rulesId.getName() + ".jar");
	if (jarFile.isFile()) {
	URL[] cp = new URL[] {toURL(jarFile)};
	return save(newEmptyMachine(new URLClassLoader(cp, systemLoader)));
	}
	}

	// Dynamically consult the rules into the machine's internal database.
	//
	String rules = read(project, rulesId);
	PrologMachineCopy pmc = consultRules("rules.pl", new StringReader(rules));
	if (pmc == null) {
	throw new CompileException("Cannot consult rules of " + project);
	}
	return pmc;
	}

	private PrologMachineCopy consultRules(String name, Reader rules)
	throws CompileException {
	BufferingPrologControl ctl = newEmptyMachine(systemLoader);
	PushbackReader in = new PushbackReader(rules, Prolog.PUSHBACK_SIZE);
	try {
	if (!ctl.execute(Prolog.BUILTIN, "consult_stream",
	SymbolTerm.intern(name), new JavaObjectTerm(in))) {
	return null;
	}
	} catch (RuntimeException e) {
	throw new CompileException("Error while consulting rules from " + name, e);
	}
	return save(ctl);
	}

	private String read(Project.NameKey project, ObjectId rulesId)
	throws CompileException {
	Repository git;
	try {
	git = gitMgr.openRepository(project);
	} catch (RepositoryNotFoundException e) {
	throw new CompileException("Cannot open repository " + project, e);
	} catch (IOException e) {
	throw new CompileException("Cannot open repository " + project, e);
	}
	try {
	ObjectLoader ldr = git.open(rulesId, Constants.OBJ_BLOB);
	byte[] raw = ldr.getCachedBytes(SRC_LIMIT);
	return RawParseUtils.decode(raw);
	} catch (LargeObjectException e) {
	throw new CompileException("rules of " + project + " are too large", e);
	} catch (RuntimeException e) {
	throw new CompileException("Cannot load rules of " + project, e);
	} catch (IOException e) {
	throw new CompileException("Cannot load rules of " + project, e);
	} finally {
	git.close();
	}
	}

	private BufferingPrologControl newEmptyMachine(ClassLoader cl) {
	BufferingPrologControl ctl = new BufferingPrologControl();
	ctl.setMaxArity(PrologEnvironment.MAX_ARITY);
	ctl.setMaxDatabaseSize(DB_MAX);
	ctl.setPrologClassLoader(new PrologClassLoader(new PredicateClassLoader(
	predicateProviders, cl)));
	ctl.setEnabled(EnumSet.allOf(Prolog.Feature.class), false);

	List<String> packages = Lists.newArrayList();
	packages.addAll(PACKAGE_LIST);
	for (PredicateProvider predicateProvider : predicateProviders) {
	packages.addAll(predicateProvider.getPackages());
	}

	// Bootstrap the interpreter and ensure there is clean state.
	ctl.initialize(packages.toArray(new String[packages.size()]));
	return ctl;
	}

	private static URL toURL(File jarFile) throws CompileException {
	try {
	return jarFile.toURI().toURL();
	} catch (MalformedURLException e) {
	throw new CompileException("Cannot create URL for " + jarFile, e);
	}
	}
	}