This is an automated email from the ASF dual-hosted git repository.

chibenwa pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-jsieve.git

commit 6a88b54958948b988e4f8fba9a296cb4f4598cf6
Author: Benoit TELLIER <[email protected]>
AuthorDate: Wed Nov 18 22:32:38 2026 +0100

    [FIX] SieveFactory: build the executable tree of a script once
    
    Each evaluation walked the parsed nodes again to build the Commands,
    Command, Test, TestList, Arguments, StringListArgument and Block it
    runs, although they depend only on the script: 15-17% of the CPU and
    37-39% of the bytes allocated by a typical filter script, 75-80% of
    the bytes of a small one.
    
    The tree validated by SieveFactory#parse is now kept on the start node,
    SieveNode#getExecutable, and every evaluation runs it. A node parsed
    otherwise gets its tree at its first evaluation. As several threads
    may evaluate the same node, the tree does not change once built: its
    lists are unmodifiable, the test list of Arguments is set up front
    instead of lazily, and it is published through a volatile field. The
    state of an evaluation stays in its context, and commands and tests
    are still new instances at each execution.
---
 .../apache/jsieve/ArgumentValidationVisitor.java   |   5 +-
 .../org/apache/jsieve/SieveParserVisitorImpl.java  |  42 ++++--
 .../java/org/apache/jsieve/parser/SieveNode.java   |  27 ++++
 .../org/apache/jsieve/ExecutableTreeReuseTest.java | 146 +++++++++++++++++++++
 4 files changed, 205 insertions(+), 15 deletions(-)

diff --git 
a/core/src/main/java/org/apache/jsieve/ArgumentValidationVisitor.java 
b/core/src/main/java/org/apache/jsieve/ArgumentValidationVisitor.java
index 866345d..a1738e3 100644
--- a/core/src/main/java/org/apache/jsieve/ArgumentValidationVisitor.java
+++ b/core/src/main/java/org/apache/jsieve/ArgumentValidationVisitor.java
@@ -48,7 +48,10 @@ class ArgumentValidationVisitor extends 
SieveParserVisitorImpl {
     }
 
     public Object visit(ASTstart node, Object data) throws SieveException {
-        node.childrenAccept(this, new ArrayList<Object>());
+        final List<Object> children = new ArrayList<Object>();
+        node.childrenAccept(this, children);
+        // The tree validated is the one evaluations run
+        node.setExecutable(new Block((Commands) children.get(0)));
         return data;
     }
 
diff --git a/core/src/main/java/org/apache/jsieve/SieveParserVisitorImpl.java 
b/core/src/main/java/org/apache/jsieve/SieveParserVisitorImpl.java
index 555f031..3b0201b 100644
--- a/core/src/main/java/org/apache/jsieve/SieveParserVisitorImpl.java
+++ b/core/src/main/java/org/apache/jsieve/SieveParserVisitorImpl.java
@@ -20,6 +20,7 @@
 package org.apache.jsieve;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 
@@ -106,8 +107,8 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
         if (null != node.getValue()) {
             argument = (Argument) node.getValue();
         } else {
-            argument = new StringListArgument(((List) node.childrenAccept(this,
-                    children)));
+            argument = new StringListArgument(Collections.unmodifiableList(
+                    (List) node.childrenAccept(this, children)));
         }
         ((List) data).add(argument);
 
@@ -129,7 +130,7 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
         while (childrenIter.hasNext()) {
             Object next = childrenIter.next();
             if (next instanceof Test)
-                testList = new TestList((Test) next);
+                testList = new TestList(Collections.singletonList((Test) 
next));
             else if (next instanceof TestList)
                 testList = (TestList) next;
             else if (next instanceof Argument) {
@@ -139,7 +140,12 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
             }
         }
 
-        Arguments arguments = new Arguments(argList, testList);
+        // Set up front: the tree is shared by evaluations, nothing may be
+        // initialised lazily
+        if (testList == null) {
+            testList = new TestList(Collections.<Test>emptyList());
+        }
+        Arguments arguments = new 
Arguments(Collections.unmodifiableList(argList), testList);
         ((List) data).add(arguments);
         return data;
     }
@@ -193,8 +199,8 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
     @SuppressWarnings("unchecked")
     public Object visit(ASTcommands node, Object data) throws SieveException {
         List<Command> children = new 
ArrayList<Command>(node.jjtGetNumChildren());
-        Commands commands = new Commands(((List) node.childrenAccept(this,
-                children)));
+        Commands commands = new Commands(Collections.unmodifiableList(
+                (List) node.childrenAccept(this, children)));
         ((List) data).add(commands);
         return data;
     }
@@ -211,12 +217,20 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
                     + (data == null ? "<null>" : data.getClass().getName())
                     + ".");
 
-        // Start is an implicit Block
-        // There will be one child, an instance of Commands
-        List children = new ArrayList(node.jjtGetNumChildren());
-        Commands commands = (Commands) ((List) node.childrenAccept(this,
-                children)).get(0);
-        Block block = new Block(commands);
+        // The executable tree depends only on the script: built at the first
+        // evaluation, it is kept on the node for the next ones. It is not
+        // changed once built, every state of an evaluation being kept in
+        // the context.
+        Block block = (Block) node.getExecutable();
+        if (block == null) {
+            // Start is an implicit Block
+            // There will be one child, an instance of Commands
+            List children = new ArrayList(node.jjtGetNumChildren());
+            Commands commands = (Commands) ((List) node.childrenAccept(this,
+                    children)).get(0);
+            block = new Block(commands);
+            node.setExecutable(block);
+        }
         context.setCoordinate(node.getCoordinate());
         // Answer the result of executing the Block
         return block.execute((MailAdapter) data, context);
@@ -248,8 +262,8 @@ public class SieveParserVisitorImpl implements 
SieveParserVisitor {
     public Object visit(ASTtest_list node, Object data) throws SieveException {
         // return visitChildren(node, data);
         List<Test> children = new ArrayList<Test>(node.jjtGetNumChildren());
-        TestList testList = new TestList(((List<Test>) 
node.childrenAccept(this,
-                children)));
+        TestList testList = new TestList(Collections.unmodifiableList(
+                (List<Test>) node.childrenAccept(this, children)));
         ((List) data).add(testList);
         return data;
     }
diff --git a/core/src/main/java/org/apache/jsieve/parser/SieveNode.java 
b/core/src/main/java/org/apache/jsieve/parser/SieveNode.java
index db9f5ab..1f15fa3 100644
--- a/core/src/main/java/org/apache/jsieve/parser/SieveNode.java
+++ b/core/src/main/java/org/apache/jsieve/parser/SieveNode.java
@@ -41,6 +41,12 @@ public class SieveNode {
 
     private Token firstToken;
 
+    /**
+     * What evaluation builds from this node, once: see
+     * {@link #getExecutable()}.
+     */
+    private volatile Object executable;
+
     private Token lastToken;
 
     /**
@@ -129,6 +135,27 @@ public class SieveNode {
         this.lastToken = lastToken;
     }
 
+    /**
+     * Gets what evaluation built from this node and keeps for the next
+     * evaluations, as the node depends only on the script. Several threads
+     * may evaluate the same node: what is kept must not change once set.
+     *
+     * @return what was set, null when nothing was
+     */
+    public Object getExecutable() {
+        return executable;
+    }
+
+    /**
+     * Sets what evaluation built from this node, see
+     * {@link #getExecutable()}.
+     *
+     * @param executable not changed once set
+     */
+    public void setExecutable(Object executable) {
+        this.executable = executable;
+    }
+
     /**
      * Gets the position of this node in the script.
      * 
diff --git a/core/src/test/java/org/apache/jsieve/ExecutableTreeReuseTest.java 
b/core/src/test/java/org/apache/jsieve/ExecutableTreeReuseTest.java
new file mode 100644
index 0000000..c3d1025
--- /dev/null
+++ b/core/src/test/java/org/apache/jsieve/ExecutableTreeReuseTest.java
@@ -0,0 +1,146 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you 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 org.apache.jsieve;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.apache.jsieve.exception.SieveException;
+import org.apache.jsieve.mail.ActionDiscard;
+import org.apache.jsieve.mail.ActionFileInto;
+import org.apache.jsieve.mail.ActionKeep;
+import org.apache.jsieve.parser.SieveNode;
+import org.apache.jsieve.parser.generated.Node;
+import org.apache.jsieve.utils.JUnitUtils;
+import org.apache.jsieve.utils.SieveMailAdapter;
+import org.junit.Test;
+
+/**
+ * A parsed script is evaluated for many mails, possibly at once: what
+ * evaluation runs is built once and shared.
+ */
+public class ExecutableTreeReuseTest {
+
+    private static final String SCRIPT = "require \"fileinto\";"
+        + " if header :contains \"Subject\" \"holidays\" { discard; }"
+        + " elsif anyof (header :is \"X-List\" \"dev\", address :domain 
\"From\" \"apache.org\") { fileinto \"dev\"; }";
+
+    @Test
+    public void theTreeShouldBeBuiltOnceAtParse() throws Exception {
+        SieveFactory factory = new ConfigurationManager().build();
+        Node node = factory.parse(script(SCRIPT));
+        Object executable = ((SieveNode) node).getExecutable();
+
+        factory.evaluate(mail("Gone for holidays", "dev"), node);
+        factory.evaluate(mail("Hello", "dev"), node);
+
+        assertThat(executable).isInstanceOf(Block.class);
+        assertThat(((SieveNode) node).getExecutable()).isSameAs(executable);
+    }
+
+    @Test
+    public void theSharedTreeShouldNotBeModifiable() throws Exception {
+        SieveFactory factory = new ConfigurationManager().build();
+        Block block = (Block) ((SieveNode) 
factory.parse(script(SCRIPT))).getExecutable();
+        Command command = block.getChildren().getChildren().get(1);
+
+        assertThatThrownBy(() -> block.getChildren().getChildren().clear())
+            .isInstanceOf(UnsupportedOperationException.class);
+        assertThatThrownBy(() -> 
command.getArguments().getArgumentList().clear())
+            .isInstanceOf(UnsupportedOperationException.class);
+        assertThatThrownBy(() -> 
command.getArguments().getTestList().getTests().clear())
+            .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    @Test
+    public void eachEvaluationShouldGetItsOwnResult() throws Exception {
+        SieveFactory factory = new ConfigurationManager().build();
+        Node node = factory.parse(script(SCRIPT));
+
+        SieveMailAdapter holidays = mail("Gone for holidays", "none");
+        SieveMailAdapter dev = mail("Hello", "dev");
+        SieveMailAdapter other = mail("Hello", "none");
+        factory.evaluate(holidays, node);
+        factory.evaluate(dev, node);
+        factory.evaluate(other, node);
+
+        
assertThat(holidays.getActions()).singleElement().isInstanceOf(ActionDiscard.class);
+        
assertThat(dev.getActions()).singleElement().isInstanceOf(ActionFileInto.class);
+        
assertThat(other.getActions()).singleElement().isInstanceOf(ActionKeep.class);
+    }
+
+    @Test
+    public void concurrentEvaluationsShouldNotInterfere() throws Exception {
+        SieveFactory factory = new ConfigurationManager().build();
+        Node node = factory.parse(script(SCRIPT));
+        ExecutorService executor = Executors.newFixedThreadPool(8);
+        try {
+            List<Future<Class<?>>> results = new ArrayList<>();
+            for (int i = 0; i < 2_000; i++) {
+                final int kind = i % 3;
+                results.add(executor.submit(() -> {
+                    SieveMailAdapter mail = kind == 0 ? mail("Gone for 
holidays", "none")
+                        : kind == 1 ? mail("Hello", "dev") : mail("Hello", 
"none");
+                    factory.evaluate(mail, node);
+                    assertThat(mail.getActions()).hasSize(1);
+                    return mail.getActions().get(0).getClass();
+                }));
+            }
+            for (int i = 0; i < results.size(); i++) {
+                Class<?> expected = i % 3 == 0 ? ActionDiscard.class : i % 3 
== 1 ? ActionFileInto.class : ActionKeep.class;
+                assertThat(results.get(i).get()).isEqualTo(expected);
+            }
+        } finally {
+            executor.shutdownNow();
+        }
+    }
+
+    @Test
+    public void 
aNodeParsedWithoutValidationShouldBuildItsTreeAtTheFirstEvaluation() throws 
Exception {
+        Node node = new 
org.apache.jsieve.parser.generated.SieveParser(script("discard;"), 
"UTF-8").start();
+        SieveFactory factory = new ConfigurationManager().build();
+        SieveMailAdapter mail = mail("Hello", "none");
+
+        factory.evaluate(mail, node);
+
+        assertThat(((SieveNode) 
node).getExecutable()).isInstanceOf(Block.class);
+        
assertThat(mail.getActions()).singleElement().isInstanceOf(ActionDiscard.class);
+    }
+
+    private static SieveMailAdapter mail(String subject, String list) throws 
Exception {
+        SieveMailAdapter mail = (SieveMailAdapter) JUnitUtils.createMail();
+        mail.getMessage().setHeader("Subject", subject);
+        mail.getMessage().setHeader("X-List", list);
+        mail.getMessage().setHeader("From", "[email protected]");
+        return mail;
+    }
+
+    private static ByteArrayInputStream script(String script) {
+        return new 
ByteArrayInputStream(script.getBytes(StandardCharsets.UTF_8));
+    }
+}


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to