### Eclipse Workspace Patch 1.0 #P oak-core Index: src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiChildNodeEntry.java =================================================================== --- src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiChildNodeEntry.java (revision 0) +++ src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiChildNodeEntry.java (working copy) @@ -0,0 +1,47 @@ +/* + * 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.segment.multi; + +import javax.annotation.Nonnull; + +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; + +public class MultiChildNodeEntry implements ChildNodeEntry { + + private final MultiNodeState baseState; + private final String name; + + MultiChildNodeEntry(MultiNodeState baseState, String name) { + this.baseState = baseState; + this.name = name; + } + + @Override + @Nonnull + public String getName() { + return name; + } + + @Override + @Nonnull + public MultiNodeState getNodeState() { + return baseState; + } + +} Index: src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiObserver.java =================================================================== --- src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiObserver.java (revision 0) +++ src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiObserver.java (working copy) @@ -0,0 +1,58 @@ +/* + * 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.segment.multi; + +import java.io.Closeable; +import java.io.IOException; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +import org.apache.jackrabbit.oak.spi.commit.CommitInfo; +import org.apache.jackrabbit.oak.spi.commit.Observer; +import org.apache.jackrabbit.oak.spi.state.NodeState; + +public class MultiObserver implements Observer, Closeable { + + private final MultiNodeStore store; + private final Observer base; + private Closeable closeable; + + MultiObserver(MultiNodeStore store, Observer base) { + this.store = store; + this.base = base; + } + + void setCloseable(Closeable closeable) { + this.closeable = closeable; + } + + @Override + public void contentChanged(@Nonnull NodeState root, + @Nullable CommitInfo info) { + MultiNodeState r = store.wrapRoot(root); + base.contentChanged(r, info); + } + + @Override + public void close() throws IOException { + closeable.close(); + } + +} Index: src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeState.java =================================================================== --- src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeState.java (revision 0) +++ src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeState.java (working copy) @@ -0,0 +1,211 @@ +/* + * 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.segment.multi; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +import org.apache.jackrabbit.oak.api.PropertyState; +import org.apache.jackrabbit.oak.commons.PathUtils; +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStateDiff; + +import com.google.common.base.Function; +import com.google.common.collect.Iterables; + +public class MultiNodeState implements NodeState { + + private final MultiNodeStore store; + private final MultiNodeState parent; + private final String name; + private final NodeState base; + + MultiNodeState(MultiNodeStore store, MultiNodeState parent, String name, NodeState base) { + this.store = store; + this.parent = parent; + this.name = name; + this.base = base; + } + + MultiNodeStore getStore() { + return store; + } + + MultiNodeState getParent() { + return parent; + } + + String getName() { + return name; + } + + NodeState unwrap() { + return base; + } + + @Override + public boolean exists() { + return base.exists(); + } + + @Override + public boolean hasProperty(@Nonnull String name) { + return base.hasProperty(name); + } + + @Override + @CheckForNull + public PropertyState getProperty(@Nonnull String name) { + return base.getProperty(name); + } + + @Override + public boolean getBoolean(@Nonnull String name) { + return base.getBoolean(name); + } + + @Override + public long getLong(String name) { + return base.getLong(name); + } + + @Override + @CheckForNull + public String getString(String name) { + return base.getString(name); + } + + @Override + @Nonnull + public Iterable getStrings(@Nonnull String name) { + return base.getStrings(name); + } + + @Override + @CheckForNull + public String getName(@Nonnull String name) { + return base.getName(name); + } + + @Override + @Nonnull + public Iterable getNames(@Nonnull String name) { + return base.getNames(name); + } + + @Override + public long getPropertyCount() { + return base.getPropertyCount(); + } + + @Override + @Nonnull + public Iterable getProperties() { + return base.getProperties(); + } + + @Override + public boolean hasChildNode(@Nonnull String name) { + // TODO multi + return base.hasChildNode(name); + } + + @Override + @Nonnull + public MultiNodeState getChildNode(@Nonnull String name) + throws IllegalArgumentException { + // TODO multi + return new MultiNodeState(store, this, name, base.getChildNode(name)); + } + + @Override + public long getChildNodeCount(long max) { + // TODO multi + return base.getChildNodeCount(max); + } + + @Override + public Iterable getChildNodeNames() { + // TODO multi + return base.getChildNodeNames(); + } + + @Override + @Nonnull + public Iterable getChildNodeEntries() { + // TODO multi + final MultiNodeState parent = this; + Iterable it = base.getChildNodeEntries(); + return Iterables.transform(it, new Function() { + + @Override + @Nullable + public MultiChildNodeEntry apply(@Nullable ChildNodeEntry input) { + if (input == null) { + return null; + } + NodeState state = input.getNodeState(); + String name = input.getName(); + MultiNodeState wrapped = store.wrap(parent, name, state); + return new MultiChildNodeEntry(wrapped, name); + } + + }); + } + + @Override + @Nonnull + public MultiNodeBuilder builder() { + return new MultiNodeBuilder(this, base.builder()); + } + + @Override + public boolean compareAgainstBaseState(NodeState base, NodeStateDiff diff) { + // TODO probably need to re-implement + MultiNodeState b = MultiNodeStore.cast(base); + return this.base.compareAgainstBaseState(b.unwrap(), diff); + } + + @Override + public final String toString() { + if (parent == null) { + return "/"; + } + return PathUtils.concat(parent.toString(), name); + } + + @Override + public int hashCode() { + return base.hashCode(); + } + + @Override + public boolean equals(Object other) { + if (other == this) { + return true; + } else if (!(other instanceof MultiNodeState)) { + return false; + } + MultiNodeState o = (MultiNodeState) other; + return o.base.equals(base); + } + +} Index: src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeStore.java =================================================================== --- src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeStore.java (revision 0) +++ src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeStore.java (working copy) @@ -0,0 +1,176 @@ +/* + * 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.segment.multi; + +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.util.Map; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; + +import org.apache.jackrabbit.oak.api.Blob; +import org.apache.jackrabbit.oak.api.CommitFailedException; +import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore; +import org.apache.jackrabbit.oak.spi.commit.CommitHook; +import org.apache.jackrabbit.oak.spi.commit.CommitInfo; +import org.apache.jackrabbit.oak.spi.commit.Observable; +import org.apache.jackrabbit.oak.spi.commit.Observer; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; +import org.apache.jackrabbit.oak.spi.state.NodeStore; + +public class MultiNodeStore implements NodeStore, Observable { + + private NodeStore read; + private NodeStore write; + private MultiNodeState root; + + public MultiNodeStore(SegmentNodeStore segmentNodeStore) { +System.out.println("new MultiNodeStore"); + this.write = segmentNodeStore; + fetchRoot(); + } + + void fetchRoot() { + this.root = wrap(null, "", write.getRoot()); + } + + MultiNodeState wrap(MultiNodeState parent, String name, NodeState base) { + return new MultiNodeState(this, parent, name, base); + } + + MultiNodeState wrapRoot(NodeState root) { + return new MultiNodeState(this, null, null, root); + } + + static MultiNodeBuilder cast(NodeBuilder builder) { + if (!(builder instanceof MultiNodeBuilder)) { + throw new IllegalArgumentException("Not a MultiNodeBuilder: " + builder); + } + return (MultiNodeBuilder) builder; + } + + static MultiNodeState cast(NodeState state) { + if (!(state instanceof MultiNodeState)) { + throw new IllegalArgumentException("Not a MultiNodeState: " + state); + } + return (MultiNodeState) state; + } + + @Override + public Closeable addObserver(Observer observer) { + MultiObserver o = new MultiObserver(this, observer); + Closeable c = ((Observable) write).addObserver(o); + o.setCloseable(c); + return o; + } + + @Override + @Nonnull + public MultiNodeState getRoot() { + return root; + } + + @Override + @Nonnull + public MultiNodeState merge(@Nonnull NodeBuilder builder, + @Nonnull CommitHook commitHook, @Nonnull CommitInfo info) + throws CommitFailedException { + MultiNodeBuilder b = cast(builder); + NodeBuilder baseBuilder = b.unwrap(); + NodeState state = write.merge(baseBuilder, commitHook, info); + // TODO check if root + root = wrapRoot(state); + return root; + } + + @Override + @Nonnull + public MultiNodeState rebase(@Nonnull NodeBuilder builder) { + MultiNodeBuilder b = cast(builder); + MultiNodeState newRootState = b.getBaseState(); + NodeBuilder builderBase = b.unwrap(); + NodeState state = write.rebase(builderBase); + b.setBase(builderBase); + // TODO check if root + root = newRootState; + return wrapRoot(state); + } + + @Override + public MultiNodeState reset(@Nonnull NodeBuilder builder) { + MultiNodeBuilder b = cast(builder); + NodeBuilder builderBase = b.unwrap(); + NodeState state = write.reset(builderBase); + // TODO check if root + root = wrapRoot(state); + return root; + } + + @Override + @Nonnull + public Blob createBlob(InputStream inputStream) throws IOException { + return write.createBlob(inputStream); + } + + @Override + @CheckForNull + public Blob getBlob(@Nonnull String reference) { + return write.getBlob(reference); + } + + @Override + @Nonnull + public String checkpoint(long lifetime, @Nonnull Map properties) { + return write.checkpoint(lifetime, properties); + } + + @Override + @Nonnull + public String checkpoint(long lifetime) { + return write.checkpoint(lifetime); + } + + @Override + @Nonnull + public Map checkpointInfo(@Nonnull String checkpoint) { + // TODO multi + return write.checkpointInfo(checkpoint); + } + + @Override + @CheckForNull + public MultiNodeState retrieve(@Nonnull String checkpoint) { + // TODO multi + NodeState state = write.retrieve(checkpoint); + if (state == null) { + return null; + } + return wrapRoot(state); + } + + @Override + public boolean release(@Nonnull String checkpoint) { + // TODO multi + return write.release(checkpoint); + } + +} Index: src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeBuilder.java =================================================================== --- src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeBuilder.java (revision 0) +++ src/main/java/org/apache/jackrabbit/oak/plugins/segment/multi/MultiNodeBuilder.java (working copy) @@ -0,0 +1,332 @@ +/* + * 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.segment.multi; + +import java.io.IOException; +import java.io.InputStream; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; + +import org.apache.jackrabbit.oak.api.Blob; +import org.apache.jackrabbit.oak.api.PropertyState; +import org.apache.jackrabbit.oak.api.Type; +import org.apache.jackrabbit.oak.plugins.memory.MemoryNodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; + +public class MultiNodeBuilder extends MemoryNodeBuilder { + +// // either the state +// private MultiNodeState state; +// +// // or the parent and the name +// private final MultiNodeBuilder parent; +// private final String name; + + private NodeBuilder baseBuilder; + + protected MultiNodeBuilder(MultiNodeBuilder parent, String name, NodeBuilder baseBuilder) { + super(parent, name); + this.baseBuilder = baseBuilder; + } + + MultiNodeBuilder(MultiNodeState state, NodeBuilder baseBuilder) { + super(state); + this.baseBuilder = baseBuilder; +// +// this.state = state; +// this.parent = null; +// this.name = null; +// this.base = base; + } +// +// MultiNodeBuilder(MultiNodeBuilder parent, String name, NodeBuilder base) { +// this.state = null; +// this.parent = parent; +// this.name = name; +// this.base = base; +// } +// +// public MultiNodeBuilder(MultiNodeBuilder old, String name) { +// this.state = old.state; +// this.parent = old.parent; +// this.name = name; +// this.base = old.base; +// } + + NodeBuilder unwrap() { + return baseBuilder; + } + + void setBase(NodeBuilder baseBuilder) { + this.baseBuilder = baseBuilder; + // TODO check it's a root +// this.state = getStore().wrapRoot(base.getBaseState()); + } +// +// private MultiNodeStore getStore() { +// if (state != null) { +// return state.getStore(); +// } +// return parent.getStore(); +// } +// + @Override + @Nonnull + public MultiNodeState getNodeState() { + NodeState baseNodeState = baseBuilder.getNodeState(); + // TODO almost a copy of getBaseState + NodeState s = getBaseState(); + if (s != null) { + MultiNodeState state = (MultiNodeState) s; + return new MultiNodeState(state.getStore(), + state.getParent(), state.getName(), baseNodeState); + } + NodeBuilder p = getParent(); + MultiNodeBuilder parent = (MultiNodeBuilder) p; + MultiNodeState parentState = parent.getBaseState(); + MultiNodeState c = new MultiNodeState( + parentState.getStore(), + parentState.getParent(), + getName(), + baseNodeState); + return c; + } + + @Override + @Nonnull + public MultiNodeState getBaseState() { + NodeState s = super.getBaseState(); + MultiNodeState state = (MultiNodeState) s; + if (state != null) { + return state; + } + NodeBuilder p = getParent(); + MultiNodeBuilder parent = (MultiNodeBuilder) p; + MultiNodeState parentState = parent.getBaseState(); + MultiNodeState c = new MultiNodeState( + parentState.getStore(), + parentState.getParent(), + getName(), + parentState.unwrap().getChildNode(getName())); + return c; + } + + @Override + public boolean exists() { + return baseBuilder.exists(); + } + + @Override + public boolean isNew() { + return baseBuilder.isNew(); + } + + @Override + public boolean isNew(String name) { + return baseBuilder.isNew(name); + } + + @Override + public boolean isModified() { + return baseBuilder.isModified(); + } + + @Override + public boolean isReplaced() { + return baseBuilder.isReplaced(); + } + + @Override + public boolean isReplaced(String name) { + return baseBuilder.isReplaced(name); + } + + @Override + public long getChildNodeCount(long max) { + return baseBuilder.getChildNodeCount(max); + } + + @Override + @Nonnull + public Iterable getChildNodeNames() { + // TODO multi + return baseBuilder.getChildNodeNames(); + } + + @Override + public boolean hasChildNode(@Nonnull String name) { + // TODO multi + return baseBuilder.hasChildNode(name); + } + + @Override + @Nonnull + public MultiNodeBuilder child(@Nonnull String name) throws IllegalArgumentException { + return new MultiNodeBuilder(this, name, baseBuilder.child(name)); + } + + @Override + @Nonnull + public MultiNodeBuilder getChildNode(@Nonnull String name) + throws IllegalArgumentException { + return new MultiNodeBuilder(this, name, baseBuilder.getChildNode(name)); + } + + @Override + @Nonnull + public MultiNodeBuilder setChildNode(@Nonnull String name) + throws IllegalArgumentException { + return new MultiNodeBuilder(this, name, baseBuilder.setChildNode(name)); + } + + @Override + @Nonnull + public MultiNodeBuilder setChildNode(@Nonnull String name, @Nonnull NodeState nodeState) + throws IllegalArgumentException { + NodeBuilder b = baseBuilder.setChildNode(name, nodeState); + return new MultiNodeBuilder(this, name, b); + } + + @Override + public boolean remove() { + return baseBuilder.remove(); + } + + @Override + public boolean moveTo(@Nonnull NodeBuilder newParent, + @Nonnull String newName) throws IllegalArgumentException { + if (newParent instanceof MultiNodeBuilder) { + newParent = MultiNodeStore.cast(newParent); + } else { + // is newParent always a MultiNodeBuilder? + System.out.println("setParent..."); + } + return baseBuilder.moveTo(newParent, newName); + } + + @Override + public long getPropertyCount() { + return baseBuilder.getPropertyCount(); + } + + @Override + @Nonnull + public Iterable getProperties() { + return baseBuilder.getProperties(); + } + + @Override + public boolean hasProperty(String name) { + return baseBuilder.hasProperty(name); + } + + @Override + @CheckForNull + public PropertyState getProperty(String name) { + return baseBuilder.getProperty(name); + } + + @Override + public boolean getBoolean(@Nonnull String name) { + return baseBuilder.getBoolean(name); + } + + @Override + @CheckForNull + public String getString(String name) { + return baseBuilder.getString(name); + } + + @Override + @CheckForNull + public String getName(@Nonnull String name) { + return baseBuilder.getName(name); + } + + @Override + @Nonnull + public Iterable getNames(@Nonnull String name) { + return baseBuilder.getNames(name); + } + + @Override + @Nonnull + public MultiNodeBuilder setProperty(@Nonnull PropertyState property) + throws IllegalArgumentException { + baseBuilder.setProperty(property); + return this; + } + + @Override + @Nonnull + public MultiNodeBuilder setProperty(String name, @Nonnull T value) + throws IllegalArgumentException { + baseBuilder.setProperty(name, value); + return this; + } + + @Override + @Nonnull + public MultiNodeBuilder setProperty(String name, @Nonnull T value, Type type) + throws IllegalArgumentException { + baseBuilder.setProperty(name, value, type); + return this; + } + + @Override + @Nonnull + public MultiNodeBuilder removeProperty(String name) { + baseBuilder.removeProperty(name); + return this; + } + + @Override + public Blob createBlob(InputStream stream) throws IOException { + return baseBuilder.createBlob(stream); + } + +// @Override +// public String toString() { +// // TODO a bit hacky +// if (state != null) { +// return "builder " + state.toString(); +// } +// MultiNodeState parentState = parent.getNodeState(); +// return "builder " + PathUtils.concat(parentState.toString(), name); +// } + + @Override + public int hashCode() { + return baseBuilder.hashCode(); + } + + @Override + public boolean equals(Object other) { + if (other == this) { + return true; + } else if (!(other instanceof MultiNodeBuilder)) { + return false; + } + MultiNodeBuilder o = (MultiNodeBuilder) other; + return o.baseBuilder.equals(baseBuilder); + } + +} Index: src/test/java/org/apache/jackrabbit/oak/NodeStoreFixture.java =================================================================== --- src/test/java/org/apache/jackrabbit/oak/NodeStoreFixture.java (revision 1702394) +++ src/test/java/org/apache/jackrabbit/oak/NodeStoreFixture.java (working copy) @@ -23,6 +23,7 @@ import org.apache.jackrabbit.oak.plugins.memory.MemoryNodeStore; import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore; import org.apache.jackrabbit.oak.plugins.segment.memory.MemoryStore; +import org.apache.jackrabbit.oak.plugins.segment.multi.MultiNodeStore; import org.apache.jackrabbit.oak.spi.state.NodeStore; /** @@ -38,7 +39,8 @@ @Override public NodeStore createNodeStore() { - return new SegmentNodeStore(new MemoryStore()); + return new MultiNodeStore(new SegmentNodeStore(new MemoryStore())); +// return new SegmentNodeStore(new MemoryStore()); } @Override #P oak-jcr Index: src/test/java/org/apache/jackrabbit/oak/jcr/NodeStoreFixture.java =================================================================== --- src/test/java/org/apache/jackrabbit/oak/jcr/NodeStoreFixture.java (revision 1702394) +++ src/test/java/org/apache/jackrabbit/oak/jcr/NodeStoreFixture.java (working copy) @@ -35,6 +35,7 @@ import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore; import org.apache.jackrabbit.oak.plugins.segment.SegmentStore; import org.apache.jackrabbit.oak.plugins.segment.memory.MemoryStore; +import org.apache.jackrabbit.oak.plugins.segment.multi.MultiNodeStore; import org.apache.jackrabbit.oak.spi.blob.BlobStore; import org.apache.jackrabbit.oak.spi.state.NodeStore; @@ -136,7 +137,7 @@ @Override public NodeStore createNodeStore() { - return new SegmentNodeStore(store == null ? new MemoryStore() : store); + return new MultiNodeStore(new SegmentNodeStore(store == null ? new MemoryStore() : store)); } @Override