diff --git oak-run/run_ace_creation.sh oak-run/run_ace_creation.sh new file mode 100755 index 0000000..b119822 --- /dev/null +++ oak-run/run_ace_creation.sh @@ -0,0 +1,54 @@ +#!/bin/sh +# +# 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. +# +TITLE=AceCreation +BENCH="AceCreationTest" +BATCH_SIZE="100" +INITIAL_ACE="0 100 200 300 500 1000 2000 3000" +FIXS="Oak-Tar" +PROFILE=true +TRANSIENT=true + + + +LOG=$TITLE"_$(date +'%Y%m%d_%H%M%S').csv" +echo "Benchmarks: $BENCH" > $LOG +echo "Fixture: $FIXS" >> $LOG +echo "Batch Size: $BATCH_SIZE" >> $LOG +echo "Number of initial ACEs: $INITIAL_ACE" >> $LOG +echo "Profiling: $PROFILE" >> $LOG + +echo "--------------------------------------" >> $LOG + +for bm in $BENCH + do + for batchsize in $BATCH_SIZE + do + for noInitialAce in $INITIAL_ACE + do + echo "Executing benchmarks with $noInitialAce initial ACE with batchsize $batchsize (transient:$TRANSIENT)" | tee -a $LOG + echo "-----------------------------------------------------------" | tee -a $LOG + rm -rf target/Jackrabbit-* target/Oak-Tar-* + cmd="java -Xmx2048m -Dprofile=$PROFILE -Druntime=$RUNTIME -Dwarmup=1 -jar target/oak-run-*-SNAPSHOT.jar benchmark --batchSize $batchsize --numberOfInitialAce $noInitialAce --transient $TRANSIENT --csvFile $LOG --report false $bm $FIXS" + echo $cmd + $cmd + done + done +done +echo "-----------------------------------------" +echo "Benchmark completed. see $LOG for details:" +cat $LOG diff --git oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java index f638b68..eba7fb7 100644 --- oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java +++ oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java @@ -42,6 +42,7 @@ import org.apache.commons.io.FileUtils; import org.apache.jackrabbit.oak.benchmark.authentication.external.ExternalLoginTest; import org.apache.jackrabbit.oak.benchmark.authentication.external.SyncAllExternalUsersTest; import org.apache.jackrabbit.oak.benchmark.authentication.external.SyncExternalUsersTest; +import org.apache.jackrabbit.oak.benchmark.authorization.AceCreationTest; import org.apache.jackrabbit.oak.benchmark.wikipedia.WikipediaImport; import org.apache.jackrabbit.oak.fixture.JackrabbitRepositoryFixture; import org.apache.jackrabbit.oak.fixture.OakFixture; @@ -116,6 +117,8 @@ public class BenchmarkRunner { .withOptionalArg().ofType(Long.class).defaultsTo(AbstractLoginTest.NO_CACHE); OptionSpec numberOfGroups = parser.accepts("numberOfGroups", "Number of groups to create.") .withOptionalArg().ofType(Integer.class).defaultsTo(LoginWithMembershipTest.NUMBER_OF_GROUPS_DEFAULT); + OptionSpec numberOfInitialAce = parser.accepts("numberOfInitialAce", "Number of ACE to create before running the test.") + .withOptionalArg().ofType(Integer.class).defaultsTo(AceCreationTest.NUMBER_OF_INITIAL_ACE_DEFAULT); OptionSpec nestedGroups = parser.accepts("nestedGroups", "Use nested groups.") .withOptionalArg().ofType(Boolean.class).defaultsTo(false); OptionSpec batchSize = parser.accepts("batchSize", "Batch size before persisting operations.") @@ -150,6 +153,9 @@ public class BenchmarkRunner { .withOptionalArg().ofType(Boolean.class).defaultsTo(Boolean.FALSE); OptionSpec autoMembership = parser.accepts("autoMembership", "Ids of those groups a given external identity automatically become member of.") .withOptionalArg().ofType(String.class).withValuesSeparatedBy(','); + OptionSpec transientWrites = parser.accepts("transient", "Do not save data.") + .withOptionalArg().ofType(Boolean.class) + .defaultsTo(Boolean.FALSE); OptionSpec nonOption = parser.nonOptions(); OptionSpec help = parser.acceptsAll(asList("h", "?", "help"), "show help").forHelp(); OptionSet options = parser.parse(args); @@ -324,6 +330,7 @@ public class BenchmarkRunner { report.value(options), randomUser.value(options)), new ConcurrentWriteACLTest(itemsToRead.value(options)), + new AceCreationTest(batchSize.value(options), numberOfInitialAce.value(options), transientWrites.value(options)), new ConcurrentEveryoneACLTest(runAsAdmin.value(options), itemsToRead.value(options)), ReadManyTest.linear("LinearReadEmpty", 1, ReadManyTest.EMPTY), ReadManyTest.linear("LinearReadFiles", 1, ReadManyTest.FILES), diff --git oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/authorization/AceCreationTest.java oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/authorization/AceCreationTest.java new file mode 100644 index 0000000..0ab1765 --- /dev/null +++ oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/authorization/AceCreationTest.java @@ -0,0 +1,141 @@ +package org.apache.jackrabbit.oak.benchmark.authorization; + +import com.google.common.collect.ImmutableMap; +import org.apache.jackrabbit.api.security.JackrabbitAccessControlList; +import org.apache.jackrabbit.commons.jackrabbit.authorization.AccessControlUtils; +import org.apache.jackrabbit.oak.benchmark.AbstractTest; +import org.apache.jackrabbit.oak.spi.security.authentication.SystemSubject; +import org.apache.jackrabbit.oak.spi.security.authorization.accesscontrol.AccessControlConstants; +import org.apache.jackrabbit.oak.spi.security.principal.EveryonePrincipal; + +import javax.jcr.Node; +import javax.jcr.RepositoryException; +import javax.jcr.Session; +import javax.jcr.Value; +import javax.jcr.security.AccessControlManager; +import javax.jcr.security.AccessControlPolicy; +import javax.jcr.security.Privilege; +import javax.security.auth.Subject; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; +import java.util.Random; + +public class AceCreationTest extends AbstractTest { + + public static final int NUMBER_OF_ACE_DEFAULT = 100; + public static final int NUMBER_OF_INITIAL_ACE_DEFAULT = 0; + private final int numberOfAce; + private final int numberOfInitialAce; + private final boolean transientWrites; + private String nodePath; + + private Session transientSession; + + public AceCreationTest(int numberOfAce, int numberOfInitialAce, boolean transientWrites) { + super(); + this.numberOfAce = numberOfAce; + this.numberOfInitialAce = numberOfInitialAce; + this.transientWrites = transientWrites; + } + + @Override + protected void beforeSuite() throws Exception { + super.beforeSuite(); + int num = new Random().nextInt(); + + Session session = createOrGetSystemSession(); + + Node node = session.getRootNode().addNode("test" + num); + + nodePath = node.getPath(); + + saveSessionIfNotTransient(session); + closeSessionIfNotTransient(session); + } + + @Override + protected void beforeTest() throws Exception { + super.beforeTest(); + + Session session = createOrGetSystemSession(); + + AccessControlManager acManager = session.getAccessControlManager(); + JackrabbitAccessControlList acl = AccessControlUtils.getAccessControlList(acManager, nodePath); + + acManager.setPolicy(nodePath, acl); + + createAce(session, numberOfInitialAce); + + saveSessionIfNotTransient(session); + closeSessionIfNotTransient(session); + } + + @Override + protected void afterTest() throws Exception { + super.afterTest(); + Session session = createOrGetSystemSession(); + + AccessControlManager acm = session.getAccessControlManager(); + AccessControlPolicy[] policies = acm.getPolicies(nodePath); + + for (AccessControlPolicy policy : policies) { + acm.removePolicy(nodePath, policy); + } + + saveSessionIfNotTransient(session); + } + + @Override + public void tearDown() throws Exception { + super.tearDown(); + + transientSession.logout(); + } + + @Override + protected void runTest() throws Exception { + Session session = createOrGetSystemSession(); + + createAce(session, numberOfAce); + saveSessionIfNotTransient(session); + closeSessionIfNotTransient(session); + } + + private void createAce(Session session, int count) throws RepositoryException { + AccessControlManager acManager = session.getAccessControlManager(); + JackrabbitAccessControlList acl = AccessControlUtils.getAccessControlList(acManager, nodePath); + + for (int i = 0; i < count; i++) { + ImmutableMap restrictions = ImmutableMap.of(AccessControlConstants.REP_GLOB, session.getValueFactory().createValue(i + "")); + acl.addEntry(EveryonePrincipal.getInstance(), AccessControlUtils.privilegesFromNames(acManager, Privilege.JCR_ADD_CHILD_NODES), true, restrictions); + } + + acManager.setPolicy(nodePath, acl); + } + + + private void saveSessionIfNotTransient(Session session) throws RepositoryException { + if (!transientWrites) { + session.save(); + } + } + + private void closeSessionIfNotTransient(Session session) { + if (!transientWrites) { + session.logout(); + } + } + + private Session createOrGetSystemSession() throws PrivilegedActionException { + if(transientWrites && transientSession != null) { + return transientSession; + } + + return (transientSession = Subject.doAsPrivileged(SystemSubject.INSTANCE, new PrivilegedExceptionAction() { + @Override + public Session run() throws Exception { + return getRepository().login(null, null); + } + }, null)); + } +}