diff options
3 files changed, 435 insertions, 2 deletions
diff --git a/gerrit-server/src/main/java/com/google/gerrit/server/patch/PublishComments.java b/gerrit-server/src/main/java/com/google/gerrit/server/patch/PublishComments.java index 99c11dea3c..ce2e796d4d 100644 --- a/gerrit-server/src/main/java/com/google/gerrit/server/patch/PublishComments.java +++ b/gerrit-server/src/main/java/com/google/gerrit/server/patch/PublishComments.java @@ -27,6 +27,7 @@ import com.google.gerrit.reviewdb.PatchSetApproval; import com.google.gerrit.reviewdb.ReviewDb; import com.google.gerrit.server.ChangeUtil; import com.google.gerrit.server.IdentifiedUser; +import com.google.gerrit.server.config.GerritServerConfig; import com.google.gerrit.server.git.GitRepositoryManager; import com.google.gerrit.server.git.MergeOp; import com.google.gerrit.server.git.MergeQueue; @@ -36,17 +37,20 @@ import com.google.gerrit.server.project.ChangeControl; import com.google.gerrit.server.project.InvalidChangeOperationException; import com.google.gerrit.server.project.NoSuchChangeException; import com.google.gerrit.server.project.NoSuchRefException; +import com.google.gerrit.server.util.BooleanExpression; import com.google.gerrit.server.workflow.FunctionState; import com.google.gwtjsonrpc.client.VoidResult; import com.google.gwtorm.client.OrmException; import com.google.inject.Inject; import com.google.inject.assistedinject.Assisted; +import org.eclipse.jgit.lib.Config; import org.eclipse.jgit.lib.Repository; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; +import java.text.ParseException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -78,6 +82,8 @@ public class PublishComments implements Callable<VoidResult> { private final MergeOp.Factory mergeFactory; private final MergeQueue merger; + private final Config config; + private final PatchSet.Id patchSetId; private final String messageText; private final Set<ApprovalCategoryValue.Id> approvals; @@ -98,7 +104,7 @@ public class PublishComments implements Callable<VoidResult> { final GitRepositoryManager gitManager, final MergeOp.Factory mergeFactory, final MergeQueue merger, - + @GerritServerConfig final Config config, @Assisted final PatchSet.Id patchSetId, @Assisted final String messageText, @Assisted final Set<ApprovalCategoryValue.Id> approvals) { @@ -113,7 +119,7 @@ public class PublishComments implements Callable<VoidResult> { this.gitManager = gitManager; this.mergeFactory = mergeFactory; this.merger = merger; - + this.config = config; this.patchSetId = patchSetId; this.messageText = messageText; this.approvals = approvals; @@ -307,6 +313,21 @@ public class PublishComments implements Callable<VoidResult> { private void email() { try { + String f = config.getString("review", null, "filter"); + if (f != null) { + // Only care about filter if available in configuration + BooleanExpression ef = new BooleanExpression(f); + HashMap<String, String> am = new HashMap<String, String>(); + for (ApprovalCategoryValue.Id a : approvals) { + am.put(a.getParentKey().get(), Short.toString(a.get())); + } + am.put("reviewer", user.getUserName()); + if (!ef.evaluate(am)) { + // If filter expression evaluates to false + // no email will be sent + return; + } + } final CommentSender cm = commentSenderFactory.create(change); cm.setFrom(user.getAccountId()); cm.setPatchSet(patchSet, patchSetInfoFactory.get(patchSetId)); @@ -317,6 +338,8 @@ public class PublishComments implements Callable<VoidResult> { log.error("Cannot send comments by email for patch set " + patchSetId, e); } catch (PatchSetInfoNotAvailableException e) { log.error("Failed to obtain PatchSetInfo for patch set " + patchSetId, e); + } catch (ParseException e) { + log.error("Failed to parse filter expression from configuration", e); } } diff --git a/gerrit-server/src/main/java/com/google/gerrit/server/util/BooleanExpression.java b/gerrit-server/src/main/java/com/google/gerrit/server/util/BooleanExpression.java new file mode 100644 index 0000000000..8b986cdb3c --- /dev/null +++ b/gerrit-server/src/main/java/com/google/gerrit/server/util/BooleanExpression.java @@ -0,0 +1,368 @@ +package com.google.gerrit.server.util; + +import java.text.ParseException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class BooleanExpression { + + private enum Token { + IDENTIFIER, NUMBER, TRUE, FALSE, LEFT_PARENTHESIS, RIGHT_PARENTHESIS, LOGICAL_AND, LOGICAL_OR, GREATER_THAN, GREATER_THAN_OR_EQUAL_TO, EQUAL_TO, NOT_EQUAL_TO, LESS_THAN, LESS_THAN_OR_EQUAL_TO, UNKNOWN, END_OF_INPUT, MINUS + } + + private static final int O_IDENTIFIER = -1; + private static final int O_NUMBER = -2; + private static final int O_TRUE = -3; + private static final int O_FALSE = -4; + private static final int O_AND = -5; + private static final int O_OR = -6; + private static final int O_EQUAL = -7; + private static final int O_GT = -8; + private static final int O_LT = -9; + private static final int O_LTOREQUAL = -10; + private static final int O_GTOREQUAL = -11; + private static final int O_NOTEQUAL = -12; + private static final int O_NONE = -1000; + + private List<Integer> program = new ArrayList<Integer>(); + private List<String> identifiers = new ArrayList<String>(); + private List<Integer> numbers = new ArrayList<Integer>(); + + private String input; + private int position; + private String value; + + private Token currentToken; + + /** + * Constructor. + * + * @param input Filter expression + */ + public BooleanExpression(String input) throws ParseException { + this.input = input; + position = 0; + nextToken(); + parseExpression(); + } + + public boolean evaluate(Map<String, String> arguments) { + String[] stack = new String[16]; + int ppos = 0; + int spos = 0; + while (ppos < program.size()) { + int o = program.get(ppos); + if (o == O_IDENTIFIER) { + stack[spos++] = identifiers.get(program.get(++ppos)); + } else if (o == O_NUMBER) { + stack[spos++] = Integer.toString(numbers.get(program.get(++ppos))); + } else if (isLogicalOperator(o)) { + String b = stack[--spos]; + String a = stack[--spos]; + if (!isBooleanLiteral(a)) { + throw new IllegalArgumentException(a + " is not a boolean expression"); + } + if (!isBooleanLiteral(b)) { + throw new IllegalArgumentException(b + " is not a boolean expression"); + } + if (o == O_AND) { + stack[spos++] = logicalAnd(a, b); + } else if (o == O_OR) { + stack[spos++] = logicalOr(a, b); + } + } else if (isComparatorOperator(o)) { + String b = stack[--spos]; + String a = stack[--spos]; + if (arguments != null && arguments.get(a) != null) { + a = arguments.get(a); + } + if (arguments != null && arguments.get(b) != null) { + b = arguments.get(b); + } + if (o == O_EQUAL) { + stack[spos++] = Boolean.toString(a.equals(b)); + } else if (o == O_NOTEQUAL) { + stack[spos++] = Boolean.toString(!a.equals(b)); + } else { + // Only integer numbers can be compared + if (!isNumber(a) || !isNumber(b)) { + stack[spos++] = "false"; + } else { + int ai = Integer.parseInt(a); + int bi = Integer.parseInt(b); + if (o == O_GT) { + stack[spos++] = Boolean.toString(ai > bi); + } else if (o == O_GTOREQUAL) { + stack[spos++] = Boolean.toString(ai >= bi); + } else if (o == O_LT) { + stack[spos++] = Boolean.toString(ai < bi); + } else if (o == O_LTOREQUAL) { + stack[spos++] = Boolean.toString(ai <= bi); + } + } + } + } else if (o == O_TRUE) { + stack[spos++] = "true"; + } else if (o == O_FALSE) { + stack[spos++] = "false"; + } + ppos++; + } + + return "true".equals(stack[spos - 1]); + } + + private boolean isBooleanLiteral(String value) { + if ("true".equals(value) || "false".equals(value)) { + return true; + } + return false; + } + + private boolean isNumber(String value) { + try { + Integer.parseInt(value); + return true; + } catch (NumberFormatException e) { + return false; + } + } + + private String logicalAnd(String a, String b) { + if ("true".equals(a) && "true".equals(b)) { + return "true"; + } + return "false"; + } + + private String logicalOr(String a, String b) { + if ("true".equals(a) || "true".equals(b)) { + return "true"; + } + return "false"; + } + + private boolean isLogicalOperator(int o) { + return (o == O_AND || o == O_OR); + } + + private boolean isComparatorOperator(int o) { + return (o == O_EQUAL || o == O_NOTEQUAL || o == O_GT || o == O_GTOREQUAL || o == O_LT || o == O_LTOREQUAL); + } + + private void nextToken() { + currentToken = Token.END_OF_INPUT; + if (position == input.length()) { + return; + } + char c = input.charAt(position); + while (Character.isWhitespace(c)) { + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + } + if (Character.isLetter(c)) { + parseIdentifier(); + } else if (Character.isDigit(c)) { + parseNumber(); + } else { + currentToken = Token.UNKNOWN; + if (c == '(') { + currentToken = Token.LEFT_PARENTHESIS; + } else if (c == ')') { + currentToken = Token.RIGHT_PARENTHESIS; + } else if (c == '>') { + currentToken = Token.GREATER_THAN; + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + if (c == '=') { + currentToken = Token.GREATER_THAN_OR_EQUAL_TO; + } + } else if (c == '<') { + currentToken = Token.LESS_THAN; + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + if (c == '=') { + currentToken = Token.LESS_THAN_OR_EQUAL_TO; + } + } else if (c == '&') { + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + if (c == '&') { + currentToken = Token.LOGICAL_AND; + } + } else if (c == '|') { + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + if (c == '|') { + currentToken = Token.LOGICAL_OR; + } + } else if (c == '=') { + currentToken = Token.EQUAL_TO; + } else if (c == '!') { + position++; + if (position == input.length()) { + return; + } + c = input.charAt(position); + if (c == '=') { + currentToken = Token.NOT_EQUAL_TO; + } + } else if (c == '-') { + currentToken = Token.MINUS; + } + if (currentToken != Token.UNKNOWN) { + position++; + } + } + } + + private void parseIdentifier() { + int s = position; + char c = input.charAt(position); + currentToken = Token.IDENTIFIER; + while (Character.isLetter(c) || c == '-' || c == '.' || c == '_') { + position++; + if (position == input.length()) { + break; + } + c = input.charAt(position); + } + value = input.substring(s, position); + if ("true".equalsIgnoreCase(value)) { + currentToken = Token.TRUE; + } else if ("false".equalsIgnoreCase(value)) { + currentToken = Token.FALSE; + } + } + + private void parseNumber() { + int s = position; + char c = input.charAt(position); + currentToken = Token.NUMBER; + while (Character.isDigit(c)) { + position++; + if (position == input.length()) { + break; + } + c = input.charAt(position); + } + value = input.substring(s, position); + } + + private void parseExpression() throws ParseException { + parseTerm(); + Token token = currentToken; + while (token == Token.LOGICAL_AND || token == Token.LOGICAL_OR) { + nextToken(); + parseTerm(); + program.add(toOperation(token)); + token = currentToken; + } + } + + private Integer toOperation(Token token) { + + int result = O_NONE; + + switch (token) { + case LOGICAL_AND: + result = O_AND; + break; + case LOGICAL_OR: + result = O_OR; + break; + case EQUAL_TO: + result = O_EQUAL; + break; + case NOT_EQUAL_TO: + result = O_NOTEQUAL; + break; + case GREATER_THAN: + result = O_GT; + break; + case GREATER_THAN_OR_EQUAL_TO: + result = O_GTOREQUAL; + break; + case LESS_THAN: + result = O_LT; + break; + case LESS_THAN_OR_EQUAL_TO: + result = O_LTOREQUAL; + break; + case TRUE: + result = O_TRUE; + break; + case FALSE: + result = O_FALSE; + break; + } + + return result; + + } + + private void parseTerm() throws ParseException { + parseElement(); + Token token = currentToken; + while (token == Token.EQUAL_TO || token == Token.NOT_EQUAL_TO || token == Token.GREATER_THAN + || token == Token.GREATER_THAN_OR_EQUAL_TO || token == Token.LESS_THAN + || token == Token.LESS_THAN_OR_EQUAL_TO) { + nextToken(); + parseElement(); + program.add(toOperation(token)); + token = currentToken; + } + } + + private void parseElement() throws ParseException { + if (currentToken == Token.LEFT_PARENTHESIS) { + nextToken(); + parseExpression(); + if (currentToken != Token.RIGHT_PARENTHESIS) { + throw new ParseException("Expected ')'", position); + } + nextToken(); + } else if (currentToken == Token.TRUE || currentToken == Token.FALSE) { + program.add(toOperation(currentToken)); + nextToken(); + } else if (currentToken == Token.IDENTIFIER) { + program.add(O_IDENTIFIER); + program.add(identifiers.size()); + identifiers.add(value); + nextToken(); + } else if (currentToken == Token.NUMBER) { + program.add(O_NUMBER); + program.add(numbers.size()); + numbers.add(Integer.parseInt(value)); + nextToken(); + } else if (currentToken == Token.MINUS) { + nextToken(); + if (currentToken == Token.NUMBER) { + program.add(O_NUMBER); + program.add(numbers.size()); + numbers.add(-Integer.parseInt(value)); + } + nextToken(); + } + else { + throw new ParseException("Unknown token", position); + } + + } +} diff --git a/gerrit-server/src/test/java/com/google/gerrit/server/util/BooleanExpressionTest.java b/gerrit-server/src/test/java/com/google/gerrit/server/util/BooleanExpressionTest.java new file mode 100644 index 0000000000..357fd7de23 --- /dev/null +++ b/gerrit-server/src/test/java/com/google/gerrit/server/util/BooleanExpressionTest.java @@ -0,0 +1,42 @@ +package com.google.gerrit.server.util; + +import static org.junit.Assert.*; + +import java.text.ParseException; +import java.util.HashMap; + +import org.junit.Test; + +public class BooleanExpressionTest { + + @Test + public void testEvaluate() { + + try { + assertTrue(new BooleanExpression("true && true && true").evaluate(null)); + assertTrue(new BooleanExpression("true || true || false").evaluate(null)); + assertTrue(new BooleanExpression("true || false || false").evaluate(null)); + assertTrue(new BooleanExpression("true || false || true").evaluate(null)); + assertTrue(new BooleanExpression("false || true || true").evaluate(null)); + assertTrue(new BooleanExpression("false || true || false").evaluate(null)); + assertFalse(new BooleanExpression("false || false || false").evaluate(null)); + assertFalse(new BooleanExpression("false && false || false").evaluate(null)); + assertFalse(new BooleanExpression("false && false && false").evaluate(null)); + assertTrue(new BooleanExpression("false && false || true").evaluate(null)); + assertTrue(new BooleanExpression("false = false").evaluate(null)); + assertTrue(new BooleanExpression("true = true").evaluate(null)); + assertFalse(new BooleanExpression("true = false").evaluate(null)); + assertFalse(new BooleanExpression("false = true").evaluate(null)); + + HashMap<String,String> hashMap = new HashMap<String, String>(); + hashMap.put("SRVW", "-1"); + hashMap.put("reviewer", "qt_sanity_bot"); + + assertTrue(new BooleanExpression("SRVW < 0 || reviewer != qt_sanity_bot").evaluate(hashMap)); + + } catch (ParseException e) { + fail(e.getMessage()); + } + } + +} |