gerrit-sshd/src/main/java/com/google/gerrit/sshd/commands/TestSubmitRule.java - gerrit - Git at Google

 // Copyright (C) 2012 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.sshd.commands;

 import com.google.gerrit.common.data.AccountInfo;
 import com.google.gerrit.common.data.SubmitRecord;
 import com.google.gerrit.reviewdb.client.Account;
 import com.google.gerrit.reviewdb.client.Change;
 import com.google.gerrit.reviewdb.client.PatchSet;
 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.reviewdb.server.ReviewDb;
 import com.google.gerrit.rules.PrologEnvironment;
 import com.google.gerrit.rules.StoredValues;
 import com.google.gerrit.server.OutputFormat;
 import com.google.gerrit.server.account.AccountCache;
 import com.google.gerrit.server.config.AnonymousCowardName;
 import com.google.gerrit.server.events.AccountAttribute;
 import com.google.gerrit.server.events.SubmitLabelAttribute;
 import com.google.gerrit.server.events.SubmitRecordAttribute;
 import com.google.gerrit.server.project.ChangeControl;
 import com.google.gerrit.server.project.ProjectState;
 import com.google.gerrit.sshd.SshCommand;
 import com.google.gson.reflect.TypeToken;
 import com.google.inject.Inject;

 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.ListTerm;
 import com.googlecode.prolog_cafe.lang.Prolog;
 import com.googlecode.prolog_cafe.lang.PrologClassLoader;
 import com.googlecode.prolog_cafe.lang.PrologException;
 import com.googlecode.prolog_cafe.lang.PrologMachineCopy;
 import com.googlecode.prolog_cafe.lang.SymbolTerm;
 import com.googlecode.prolog_cafe.lang.Term;
 import com.googlecode.prolog_cafe.lang.VariableTerm;

 import org.kohsuke.args4j.Argument;
 import org.kohsuke.args4j.Option;

 import java.io.InputStreamReader;
 import java.io.PushbackReader;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;

 /** Command that allows testing of prolog submit-rules in a live instance. */
 final class TestSubmitRule extends SshCommand {
   @Inject
   private ReviewDb db;

   @Inject
   private PrologEnvironment.Factory envFactory;

   @Inject
   private ChangeControl.Factory ccFactory;

   @Inject
   private AccountCache accountCache;

   final @AnonymousCowardName String anonymousCowardName;

   @Argument(index = 0, required = true, usage = "ChangeId to load in prolog environment")
   private String changeId;

   @Option(name = "-s",
       usage = "Read prolog script from stdin instead of reading rules.pl from the refs/meta/config branch")
   private boolean useStdin;

   @Option(name = "--format", metaVar = "FMT", usage = "Output display format")
   private OutputFormat format = OutputFormat.TEXT;

   @Option(name = "--no-filters", aliases = {"-n"},
       usage = "Don't run the submit_filter/2 from the parent projects")
   private boolean skipSubmitFilters;

   private static final String[] PACKAGE_LIST = {Prolog.BUILTIN, "gerrit"};

   @Inject
   public TestSubmitRule(@AnonymousCowardName String anonymous) {
     anonymousCowardName = anonymous;
   }
   private PrologMachineCopy newMachine() {
     BufferingPrologControl ctl = new BufferingPrologControl();
     ctl.setMaxDatabaseSize(16 * 1024);
     ctl.setPrologClassLoader(new PrologClassLoader(getClass().getClassLoader()));
     return PrologMachineCopy.save(ctl);
   }

   @Override
   protected void run() throws UnloggedFailure {
     PushbackReader inReader = new PushbackReader(new InputStreamReader(in));

     try {
       PrologEnvironment pcl;

       List<Change> changeList =
           db.changes().byKey(new Change.Key(changeId)).toList();
       if (changeList.size() != 1)
         throw new UnloggedFailure(1, "Invalid ChangeId");

       Change c = changeList.get(0);
       PatchSet ps = db.patchSets().get(c.currentPatchSetId());
       // Will throw exception if current user can not access this change, and
       // thus will leak information that a change-id is valid even though the
       // user are not allowed to see the change.
       // See http://code.google.com/p/gerrit/issues/detail?id=1586
       ChangeControl cc = ccFactory.controlFor(c);
       ProjectState projectState = cc.getProjectControl().getProjectState();

       if (useStdin) {
         pcl = envFactory.create(newMachine());
       } else {
         pcl = projectState.newPrologEnvironment();
       }

       pcl.set(StoredValues.REVIEW_DB, db);
       pcl.set(StoredValues.CHANGE, c);
       pcl.set(StoredValues.PATCH_SET, ps);
       pcl.set(StoredValues.CHANGE_CONTROL, cc);
       if (useStdin) {
         pcl.initialize(PACKAGE_LIST);
         pcl.execute(Prolog.BUILTIN, "consult_stream",
             SymbolTerm.intern("stdin"), new JavaObjectTerm(inReader));
       }

       List<Term> results = new ArrayList<Term>();
       Term submitRule =
           pcl.once("gerrit", "locate_submit_rule", new VariableTerm());

       for (Term[] template : pcl.all("gerrit", "can_submit", submitRule,
           new VariableTerm())) {
         results.add(template[1]);
       }

       if (!skipSubmitFilters) {
         runSubmitFilters(projectState, results, pcl);
       }

       List<SubmitRecord> res = cc.resultsToSubmitRecord(submitRule, results);
       for (SubmitRecord r : res) {
         if (format.isJson()) {
           SubmitRecordAttribute submitRecord = new SubmitRecordAttribute();
           submitRecord.status = r.status.name();

           List<SubmitLabelAttribute> submitLabels = new LinkedList<SubmitLabelAttribute>();
           for(SubmitRecord.Label l : r.labels) {
             SubmitLabelAttribute label = new SubmitLabelAttribute();
             label.label = l.label;
             label.status= l.status.name();
             if(l.appliedBy != null) {
               Account a = accountCache.get(l.appliedBy).getAccount();
               label.by = new AccountAttribute();
               label.by.email = a.getPreferredEmail();
               label.by.name = a.getFullName();
               label.by.username = a.getUserName();
             }
             submitLabels.add(label);
           }
           submitRecord.labels = submitLabels;
           format.newGson().toJson(submitRecord, new TypeToken<SubmitRecordAttribute>() {}.getType(), stdout);
           stdout.print('\n');
         } else {
           for(SubmitRecord.Label l : r.labels) {
             stdout.print(l.label + ": " + l.status);
             if(l.appliedBy != null) {
               AccountInfo a = new AccountInfo(accountCache.get(l.appliedBy).getAccount());
               stdout.print(" by " + a.getNameEmail(anonymousCowardName));
             }
             stdout.print('\n');
           }
           stdout.print("\n" + r.status.name() + "\n");
         }
       }
     } catch (Exception e) {
       throw new UnloggedFailure("Processing of prolog script failed: " + e);
     }
   }

   private void runSubmitFilters(ProjectState projectState, List<Term> results,
       PrologEnvironment pcl) throws UnloggedFailure {
     ProjectState parentState = projectState.getParentState();
     PrologEnvironment childEnv = pcl;
     Set<Project.NameKey> projectsSeen = new HashSet<Project.NameKey>();
     projectsSeen.add(projectState.getProject().getNameKey());

     while (parentState != null) {
       if (!projectsSeen.add(parentState.getProject().getNameKey())) {
         // parent has been seen before, stop walk up inheritance tree
         break;
       }
       PrologEnvironment parentEnv;
       try {
         parentEnv = parentState.newPrologEnvironment();
       } catch (CompileException err) {
         throw new UnloggedFailure("Cannot consult rules.pl for "
             + parentState.getProject().getName() + err);
       }

       parentEnv.copyStoredValues(childEnv);
       Term filterRule =
           parentEnv.once("gerrit", "locate_submit_filter", new VariableTerm());
       if (filterRule != null) {
         try {
           Term resultsTerm = ChangeControl.toListTerm(results);
           results.clear();
           Term[] template =
               parentEnv.once("gerrit", "filter_submit_results", filterRule,
                   resultsTerm, new VariableTerm());
           @SuppressWarnings("unchecked")
           final List<? extends Term> termList =
               ((ListTerm) template[2]).toJava();
           results.addAll(termList);
         } catch (PrologException err) {
           throw new UnloggedFailure("Exception calling " + filterRule + " of "
               + parentState.getProject().getName() + err);
         } catch (RuntimeException err) {
           throw new UnloggedFailure("Exception calling " + filterRule + " of "
               + parentState.getProject().getName() + err);
         }
       }

       parentState = parentState.getParentState();
       childEnv = parentEnv;
     }
   }
 }
	// Copyright (C) 2012 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.sshd.commands;

	import com.google.gerrit.common.data.AccountInfo;
	import com.google.gerrit.common.data.SubmitRecord;
	import com.google.gerrit.reviewdb.client.Account;
	import com.google.gerrit.reviewdb.client.Change;
	import com.google.gerrit.reviewdb.client.PatchSet;
	import com.google.gerrit.reviewdb.client.Project;
	import com.google.gerrit.reviewdb.server.ReviewDb;
	import com.google.gerrit.rules.PrologEnvironment;
	import com.google.gerrit.rules.StoredValues;
	import com.google.gerrit.server.OutputFormat;
	import com.google.gerrit.server.account.AccountCache;
	import com.google.gerrit.server.config.AnonymousCowardName;
	import com.google.gerrit.server.events.AccountAttribute;
	import com.google.gerrit.server.events.SubmitLabelAttribute;
	import com.google.gerrit.server.events.SubmitRecordAttribute;
	import com.google.gerrit.server.project.ChangeControl;
	import com.google.gerrit.server.project.ProjectState;
	import com.google.gerrit.sshd.SshCommand;
	import com.google.gson.reflect.TypeToken;
	import com.google.inject.Inject;

	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.ListTerm;
	import com.googlecode.prolog_cafe.lang.Prolog;
	import com.googlecode.prolog_cafe.lang.PrologClassLoader;
	import com.googlecode.prolog_cafe.lang.PrologException;
	import com.googlecode.prolog_cafe.lang.PrologMachineCopy;
	import com.googlecode.prolog_cafe.lang.SymbolTerm;
	import com.googlecode.prolog_cafe.lang.Term;
	import com.googlecode.prolog_cafe.lang.VariableTerm;

	import org.kohsuke.args4j.Argument;
	import org.kohsuke.args4j.Option;

	import java.io.InputStreamReader;
	import java.io.PushbackReader;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Set;

	/** Command that allows testing of prolog submit-rules in a live instance. */
	final class TestSubmitRule extends SshCommand {
	@Inject
	private ReviewDb db;

	@Inject
	private PrologEnvironment.Factory envFactory;

	@Inject
	private ChangeControl.Factory ccFactory;

	@Inject
	private AccountCache accountCache;

	final @AnonymousCowardName String anonymousCowardName;

	@Argument(index = 0, required = true, usage = "ChangeId to load in prolog environment")
	private String changeId;

	@Option(name = "-s",
	usage = "Read prolog script from stdin instead of reading rules.pl from the refs/meta/config branch")
	private boolean useStdin;

	@Option(name = "--format", metaVar = "FMT", usage = "Output display format")
	private OutputFormat format = OutputFormat.TEXT;

	@Option(name = "--no-filters", aliases = {"-n"},
	usage = "Don't run the submit_filter/2 from the parent projects")
	private boolean skipSubmitFilters;

	private static final String[] PACKAGE_LIST = {Prolog.BUILTIN, "gerrit"};

	@Inject
	public TestSubmitRule(@AnonymousCowardName String anonymous) {
	anonymousCowardName = anonymous;
	}
	private PrologMachineCopy newMachine() {
	BufferingPrologControl ctl = new BufferingPrologControl();
	ctl.setMaxDatabaseSize(16 * 1024);
	ctl.setPrologClassLoader(new PrologClassLoader(getClass().getClassLoader()));
	return PrologMachineCopy.save(ctl);
	}

	@Override
	protected void run() throws UnloggedFailure {
	PushbackReader inReader = new PushbackReader(new InputStreamReader(in));

	try {
	PrologEnvironment pcl;

	List<Change> changeList =
	db.changes().byKey(new Change.Key(changeId)).toList();
	if (changeList.size() != 1)
	throw new UnloggedFailure(1, "Invalid ChangeId");

	Change c = changeList.get(0);
	PatchSet ps = db.patchSets().get(c.currentPatchSetId());
	// Will throw exception if current user can not access this change, and
	// thus will leak information that a change-id is valid even though the
	// user are not allowed to see the change.
	// See http://code.google.com/p/gerrit/issues/detail?id=1586
	ChangeControl cc = ccFactory.controlFor(c);
	ProjectState projectState = cc.getProjectControl().getProjectState();

	if (useStdin) {
	pcl = envFactory.create(newMachine());
	} else {
	pcl = projectState.newPrologEnvironment();
	}

	pcl.set(StoredValues.REVIEW_DB, db);
	pcl.set(StoredValues.CHANGE, c);
	pcl.set(StoredValues.PATCH_SET, ps);
	pcl.set(StoredValues.CHANGE_CONTROL, cc);
	if (useStdin) {
	pcl.initialize(PACKAGE_LIST);
	pcl.execute(Prolog.BUILTIN, "consult_stream",
	SymbolTerm.intern("stdin"), new JavaObjectTerm(inReader));
	}

	List<Term> results = new ArrayList<Term>();
	Term submitRule =
	pcl.once("gerrit", "locate_submit_rule", new VariableTerm());

	for (Term[] template : pcl.all("gerrit", "can_submit", submitRule,
	new VariableTerm())) {
	results.add(template[1]);
	}

	if (!skipSubmitFilters) {
	runSubmitFilters(projectState, results, pcl);
	}

	List<SubmitRecord> res = cc.resultsToSubmitRecord(submitRule, results);
	for (SubmitRecord r : res) {
	if (format.isJson()) {
	SubmitRecordAttribute submitRecord = new SubmitRecordAttribute();
	submitRecord.status = r.status.name();

	List<SubmitLabelAttribute> submitLabels = new LinkedList<SubmitLabelAttribute>();
	for(SubmitRecord.Label l : r.labels) {
	SubmitLabelAttribute label = new SubmitLabelAttribute();
	label.label = l.label;
	label.status= l.status.name();
	if(l.appliedBy != null) {
	Account a = accountCache.get(l.appliedBy).getAccount();
	label.by = new AccountAttribute();
	label.by.email = a.getPreferredEmail();
	label.by.name = a.getFullName();
	label.by.username = a.getUserName();
	}
	submitLabels.add(label);
	}
	submitRecord.labels = submitLabels;
	format.newGson().toJson(submitRecord, new TypeToken<SubmitRecordAttribute>() {}.getType(), stdout);
	stdout.print('\n');
	} else {
	for(SubmitRecord.Label l : r.labels) {
	stdout.print(l.label + ": " + l.status);
	if(l.appliedBy != null) {
	AccountInfo a = new AccountInfo(accountCache.get(l.appliedBy).getAccount());
	stdout.print(" by " + a.getNameEmail(anonymousCowardName));
	}
	stdout.print('\n');
	}
	stdout.print("\n" + r.status.name() + "\n");
	}
	}
	} catch (Exception e) {
	throw new UnloggedFailure("Processing of prolog script failed: " + e);
	}
	}

	private void runSubmitFilters(ProjectState projectState, List<Term> results,
	PrologEnvironment pcl) throws UnloggedFailure {
	ProjectState parentState = projectState.getParentState();
	PrologEnvironment childEnv = pcl;
	Set<Project.NameKey> projectsSeen = new HashSet<Project.NameKey>();
	projectsSeen.add(projectState.getProject().getNameKey());

	while (parentState != null) {
	if (!projectsSeen.add(parentState.getProject().getNameKey())) {
	// parent has been seen before, stop walk up inheritance tree
	break;
	}
	PrologEnvironment parentEnv;
	try {
	parentEnv = parentState.newPrologEnvironment();
	} catch (CompileException err) {
	throw new UnloggedFailure("Cannot consult rules.pl for "
	+ parentState.getProject().getName() + err);
	}

	parentEnv.copyStoredValues(childEnv);
	Term filterRule =
	parentEnv.once("gerrit", "locate_submit_filter", new VariableTerm());
	if (filterRule != null) {
	try {
	Term resultsTerm = ChangeControl.toListTerm(results);
	results.clear();
	Term[] template =
	parentEnv.once("gerrit", "filter_submit_results", filterRule,
	resultsTerm, new VariableTerm());
	@SuppressWarnings("unchecked")
	final List<? extends Term> termList =
	((ListTerm) template[2]).toJava();
	results.addAll(termList);
	} catch (PrologException err) {
	throw new UnloggedFailure("Exception calling " + filterRule + " of "
	+ parentState.getProject().getName() + err);
	} catch (RuntimeException err) {
	throw new UnloggedFailure("Exception calling " + filterRule + " of "
	+ parentState.getProject().getName() + err);
	}
	}

	parentState = parentState.getParentState();
	childEnv = parentEnv;
	}
	}
	}