diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDelete.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDelete.java new file mode 100644 index 0000000..d88104f --- /dev/null +++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDelete.java @@ -0,0 +1,119 @@ +/* + * 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.jackrabbit.oak.plugins.index.lucene.property; + +import java.util.function.Supplier; + +import com.google.common.base.Stopwatch; +import org.apache.jackrabbit.oak.api.CommitFailedException; +import org.apache.jackrabbit.oak.commons.PathUtils; +import org.apache.jackrabbit.oak.spi.commit.CommitHook; +import org.apache.jackrabbit.oak.spi.commit.CommitInfo; +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStateUtils; +import org.apache.jackrabbit.oak.spi.state.NodeStore; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class RecursiveDelete { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final NodeStore nodeStore; + private final CommitHook commitHook; + private final Supplier commitInfo; + private final String path; + private int batchSize = 1024; + private int numRemoved = 0; + private int mergeCount; + private NodeBuilder builder; + + public RecursiveDelete(NodeStore nodeStore, CommitHook commitHook, + Supplier commitInfo, String path) { + this.nodeStore = nodeStore; + this.commitHook = commitHook; + this.commitInfo = commitInfo; + this.path = path; + } + + public void run() throws CommitFailedException { + NodeState root = nodeStore.getRoot(); + builder = root.builder(); + NodeState node = NodeStateUtils.getNode(root, path); + Stopwatch w = Stopwatch.createStarted(); + + int currentSize = delete(node, path); + save(path, currentSize, true); + + log.debug("Removed subtree under [{}] with {} child nodes " + + "in {} ({} saves)", path, numRemoved, w, mergeCount); + } + + public int getNumRemoved() { + return numRemoved; + } + + public int getMergeCount() { + return mergeCount; + } + + public void setBatchSize(int batchSize) { + this.batchSize = batchSize; + } + + private int delete(NodeState node, String path) throws CommitFailedException { + int currentSize = deleteChildNodes(node, path); + child(builder, path).remove(); + numRemoved++; + return currentSize + 1; + } + + private int deleteChildNodes(NodeState node, String path) throws CommitFailedException { + int currentSize = 0; + for (ChildNodeEntry cne : node.getChildNodeEntries()) { + String name = cne.getName(); + String childPath = PathUtils.concat(path, name); + + currentSize += delete(cne.getNodeState(), childPath); + if (save(childPath, currentSize, false)) { + currentSize = 0; + } + } + return currentSize; + } + + private boolean save(String path, int currentSize, boolean force) throws CommitFailedException { + if (currentSize >= batchSize || force) { + log.debug("Deleting {} nodes on {} ({} removed so far)", currentSize, path, numRemoved); + nodeStore.merge(builder, commitHook, commitInfo.get()); + builder = nodeStore.getRoot().builder(); + mergeCount++; + return true; + } + return false; + } + + private static NodeBuilder child(NodeBuilder nb, String path) { + for (String name : PathUtils.elements(path)) { + nb = nb.getChildNode(name); + } + return nb; + } +} diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDeleteTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDeleteTest.java new file mode 100644 index 0000000..3d665ba --- /dev/null +++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/property/RecursiveDeleteTest.java @@ -0,0 +1,139 @@ +/* + * 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.jackrabbit.oak.plugins.index.lucene.property; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Random; +import java.util.concurrent.atomic.AtomicInteger; + +import com.google.common.collect.Iterables; +import com.google.common.collect.TreeTraverser; +import org.apache.jackrabbit.oak.api.CommitFailedException; +import org.apache.jackrabbit.oak.commons.FixturesHelper; +import org.apache.jackrabbit.oak.fixture.DocumentMemoryFixture; +import org.apache.jackrabbit.oak.fixture.MemoryFixture; +import org.apache.jackrabbit.oak.fixture.NodeStoreFixture; +import org.apache.jackrabbit.oak.plugins.index.lucene.TestUtil; +import org.apache.jackrabbit.oak.spi.commit.CommitInfo; +import org.apache.jackrabbit.oak.spi.commit.EmptyHook; +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStateUtils; +import org.apache.jackrabbit.oak.spi.state.NodeStore; +import org.junit.After; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +import static org.apache.jackrabbit.oak.spi.state.NodeStateUtils.getNode; +import static org.junit.Assert.*; + +@RunWith(Parameterized.class) +public class RecursiveDeleteTest { + private final NodeStoreFixture fixture; + private final NodeStore nodeStore; + private String testNodePath = "/content/testNode"; + private Random rnd = new Random(); + private int maxBucketSize = 100; + private int maxDepth = 4; + + public RecursiveDeleteTest(NodeStoreFixture fixture) { + this.nodeStore = fixture.createNodeStore(); + this.fixture = fixture; + } + + @After + public void tearDown(){ + fixture.dispose(nodeStore); + } + + @Parameterized.Parameters(name="{0}") + public static Collection fixtures() { + Collection result = new ArrayList(); + result.add(new Object[]{new MemoryFixture()}); + result.add(new Object[]{new DocumentMemoryFixture()}); + return result; + } + + @Test + public void recursiveDelete() throws Exception{ + int actualCount = createSubtree(10000); + assertEquals(actualCount, getSubtreeCount(getNode(nodeStore.getRoot(), testNodePath))); + + RecursiveDelete rd = new RecursiveDelete(nodeStore, EmptyHook.INSTANCE, () -> CommitInfo.EMPTY, testNodePath); + rd.setBatchSize(100); + rd.run(); + + assertEquals(actualCount, rd.getNumRemoved()); + assertFalse(getNode(nodeStore.getRoot(), testNodePath).exists()); + + System.out.println(rd.getMergeCount()); + System.out.println(actualCount); + } + + private int createSubtree(int maxNodesCount) throws CommitFailedException { + NodeBuilder builder = nodeStore.getRoot().builder(); + NodeBuilder child = TestUtil.child(builder, testNodePath); + AtomicInteger maxNodes = new AtomicInteger(maxNodesCount); + int actualCount = createChildren(child, maxNodes, 0); + nodeStore.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY); + return actualCount + 1; + } + + private int createChildren(NodeBuilder child, AtomicInteger maxNodes, int depth) { + if (maxNodes.get() <= 0 || depth > maxDepth) { + return 0; + } + + int totalCount = 0; + int childCount = rnd.nextInt(maxBucketSize); + if (childCount == 0) { + childCount = 1; + } + + List children = new ArrayList<>(); + for (int i = 0; i < childCount && maxNodes.get() > 0; i++){ + maxNodes.decrementAndGet(); + totalCount++; + children.add(child.child("c"+i)); + + } + + for (NodeBuilder c : children) { + totalCount += createChildren(c, maxNodes, depth + 1); + } + + return totalCount; + } + + private int getSubtreeCount(NodeState state){ + TreeTraverser t = new TreeTraverser() { + @Override + public Iterable children(NodeState root) { + return Iterables.transform(root.getChildNodeEntries(), ChildNodeEntry::getNodeState); + } + }; + return t.preOrderTraversal(state).size(); + } + +} \ No newline at end of file