diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfo.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfo.java new file mode 100644 index 0000000..6db6a80 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfo.java @@ -0,0 +1,104 @@ +/* + * 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.multiplex; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.List; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; + +import org.apache.jackrabbit.oak.spi.mount.Mount; + +import static org.apache.jackrabbit.oak.commons.PathUtils.isAncestor; + +final class MountInfo { + + private static final Function SANITIZE_PATH = new Function() { + @Override + public String apply(String input) { + if ( input.endsWith("/") && input.length() > 1) { + return input.substring(0, input.length() - 1); + } + return input; + } + }; + + private final Mount mount; + private final List includedPaths; + + public MountInfo(Mount mount, List includedPaths){ + this.mount = mount; + this.includedPaths = cleanCopy(includedPaths); + } + + public Mount getMount() { + return mount; + } + + public boolean isUnder(String path) { + + path = SANITIZE_PATH.apply(path); + + for (String includedPath : includedPaths) { + if (isAncestor(path, includedPath)) { + return true; + } + } + + return false; + } + + public boolean isMounted(String path){ + + if (path.contains(mount.getPathFragmentName())){ + return true; + } + + path = SANITIZE_PATH.apply(path); + + //TODO may be optimized via trie + + for (String includedPath : includedPaths){ + if ( includedPath.equals(path) || isAncestor(includedPath, path)) { + return true; + } + } + return false; + } + + @Override + public String toString() { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + pw.print(mount); + for (String path : includedPaths) { + pw.printf("\t%s%n", path); + } + return sw.toString(); + } + + private ImmutableList cleanCopy(List includedPaths) { + // ensure that paths don't have trailing slashes - this triggers an assertion in PahtUtils isAncestor + return ImmutableList.copyOf(Iterables.transform(includedPaths, SANITIZE_PATH)); + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderService.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderService.java new file mode 100644 index 0000000..a1cdbc2 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderService.java @@ -0,0 +1,99 @@ +/* + * 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.multiplex; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Property; +import org.apache.felix.scr.annotations.PropertyUnbounded; +import org.apache.jackrabbit.oak.commons.PropertiesUtil; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; +import org.osgi.framework.BundleContext; +import org.osgi.framework.ServiceRegistration; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Component(metatype = true, label = "Apache Jackrabbit Oak MountInfoProvider") +public class MountInfoProviderService { + + @Property(label = "Mounted paths", + unbounded = PropertyUnbounded.ARRAY, + description = "Paths which are part of private mount" + ) + private static final String PROP_MOUNT_PATHS = "mountedPaths"; + + static final String PROP_MOUNT_NAME_DEFAULT = "private"; + + @Property(label = "Mount name", + description = "Name of the mount", + value = PROP_MOUNT_NAME_DEFAULT + ) + private static final String PROP_MOUNT_NAME = "mountName"; + + private static final boolean PROP_MOUNT_READONLY_DEFAULT = false; + + @Property(label = "Readonly", + description = "If enabled then mount would be considered as readonly", + boolValue = PROP_MOUNT_READONLY_DEFAULT + ) + private static final String PROP_MOUNT_READONLY = "readOnlyMount"; + + private final Logger log = LoggerFactory.getLogger(getClass()); + + private ServiceRegistration reg; + + @Activate + private void activate(BundleContext bundleContext, Map config) { + String[] paths = PropertiesUtil.toStringArray(config.get(PROP_MOUNT_PATHS)); + String mountName = PropertiesUtil.toString(config.get(PROP_MOUNT_NAME), PROP_MOUNT_NAME_DEFAULT); + boolean readOnly = PropertiesUtil.toBoolean(config.get(PROP_MOUNT_READONLY), PROP_MOUNT_READONLY_DEFAULT); + + MountInfoProvider mip = MountInfoProvider.DEFAULT; + if (paths != null){ + Mount mount = new Mount(mountName.trim(), readOnly); + List trimmedPaths = new ArrayList(paths.length); + for (String path : paths){ + trimmedPaths.add(path.trim()); + } + MountInfo mi = new MountInfo(mount, trimmedPaths); + mip = new SimpleMountInfoProvider(Collections.singletonList(mi)); + log.info("Enabling mount for {}", mi); + } else { + log.info("No mount config provided. Mounting would be disabled"); + } + + reg = bundleContext.registerService(MountInfoProvider.class.getName(), mip, null); + } + + @Deactivate + private void deactivate() { + if (reg != null) { + reg.unregister(); + reg = null; + } + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProvider.java new file mode 100644 index 0000000..6e3e873 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProvider.java @@ -0,0 +1,121 @@ +/* + * 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.multiplex; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; + +import static java.util.Arrays.asList; + +/** + * A simple and inefficient implementation to manage mountpoints + */ +public class SimpleMountInfoProvider implements MountInfoProvider { + private final List mountInfos; + private final Map mounts; + private final boolean hasMounts; + + public SimpleMountInfoProvider(List mountInfos){ + this.mountInfos = ImmutableList.copyOf(mountInfos); + this.mounts = getMounts(mountInfos); + this.hasMounts = !mountInfos.isEmpty(); + //TODO add validation of mountpoints + } + + @Override + public Mount getMountByPath(String path) { + for (MountInfo md : mountInfos){ + if (md.isMounted(path)){ + return md.getMount(); + } + } + return Mount.DEFAULT; + } + + @Override + public Collection getNonDefaultMounts() { + return mounts.values(); + } + + @Override + public Mount getMountByName(String name) { + return mounts.get(name); + } + + @Override + public boolean hasNonDefaultMounts() { + return hasMounts; + } + + + @Override + public Collection getMountsPlacedUnder(String path) { + Collection mounts = Lists.newArrayList(); + for ( MountInfo mount : mountInfos ) { + if ( mount.isUnder(path) ) { + mounts.add(mount.getMount()); + } + } + return mounts; + } + + //~----------------------------------------< builder > + + public static Builder newBuilder(){ + return new Builder(); + } + + public static final class Builder { + private final List mounts = Lists.newArrayListWithCapacity(1); + + public Builder mount(String name, String... paths) { + mounts.add(new MountInfo(new Mount(name), asList(paths))); + return this; + } + + public Builder readOnlyMount(String name, String... paths) { + mounts.add(new MountInfo(new Mount(name, true), asList(paths))); + return this; + } + + public SimpleMountInfoProvider build() { + return new SimpleMountInfoProvider(mounts); + } + } + + //~----------------------------------------< private > + + private static Map getMounts(List mountInfos) { + Map mounts = Maps.newHashMap(); + for (MountInfo mi : mountInfos){ + mounts.put(mi.getMount().getName(), mi.getMount()); + } + return ImmutableMap.copyOf(mounts); + } + +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/Mount.java oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/Mount.java new file mode 100644 index 0000000..45e597f --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/Mount.java @@ -0,0 +1,92 @@ +/* + * 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.spi.mount; + +import static com.google.common.base.Preconditions.checkNotNull; + +public final class Mount { + /** + * Default Mount info which indicates that no explicit mount + * is created for given path + */ + public static final Mount DEFAULT = new Mount("", false, true); + + private final String name; + private final boolean readOnly; + private final boolean defaultMount; + private final String pathFragmentName; + + public Mount(String name){ + this(name, false); + } + + public Mount(String name, boolean readOnly) { + this(name, readOnly, false); + } + + private Mount(String name, boolean readOnly, boolean defaultMount){ + this.name = checkNotNull(name, "Mount name must not be null"); + this.readOnly = readOnly; + this.defaultMount = defaultMount; + this.pathFragmentName = "oak:" + name; + } + + public String getName() { + return name; + } + + public boolean isReadOnly() { + return readOnly; + } + + public boolean isDefault(){ + return defaultMount; + } + + /** + * Decorated mount name which is meant to be used for constructing path + * which should become part of given mount + */ + public String getPathFragmentName() { + return pathFragmentName; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Mount mount = (Mount) o; + + return name.equals(mount.name); + } + + @Override + public int hashCode() { + return name.hashCode(); + } + + @Override + public String toString() { + String readAttr = readOnly ? "r" : "rw"; + String displayName = defaultMount ? "default" : name; + return displayName + "(" + readAttr + ")"; + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/MountInfoProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/MountInfoProvider.java new file mode 100644 index 0000000..b90d1ce --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/MountInfoProvider.java @@ -0,0 +1,90 @@ +/* + * 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.spi.mount; + +import java.util.Collection; +import java.util.Collections; + +import javax.annotation.CheckForNull; + +public interface MountInfoProvider { + MountInfoProvider DEFAULT = new MountInfoProvider() { + @Override + public Mount getMountByPath(String path) { + return Mount.DEFAULT; + } + + @Override + public Collection getNonDefaultMounts() { + return Collections.emptySet(); + } + + @Override + public Mount getMountByName(String name) { + return null; + } + + @Override + public boolean hasNonDefaultMounts() { + return false; + } + + public Collection getMountsPlacedUnder(String path) { + return Collections.emptySet(); + }; + }; + + /** + * Maps a given path to logical store name. + * + * @param path node path for which backing store location is to be determined + * @return mountInfo for the given path. If no explicit mount configured then + * default mount would be returned + */ + Mount getMountByPath(String path); + + /** + * Set of non default mount points configured for the setup + */ + Collection getNonDefaultMounts(); + + /** + * Returns the mount instance for given mount name + * + * @param name name of the mount + * @return mount instance for given mount name. If no mount exists for given name + * null would be returned + */ + @CheckForNull + Mount getMountByName(String name); + + /** + * Return true if there are explicit mounts configured + */ + boolean hasNonDefaultMounts(); + + /** + * Returns all mounts placed under the specified path + * + * @param path the path under which mounts are to be found + * @return a collection of mounts, possibly empty + */ + Collection getMountsPlacedUnder(String path); +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/package-info.java oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/package-info.java new file mode 100644 index 0000000..1acc587 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/spi/mount/package-info.java @@ -0,0 +1,24 @@ +/* + * 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. + */ +@Version("1.0.0") +@Export(optional = "provide:=true") +package org.apache.jackrabbit.oak.spi.mount; + +import aQute.bnd.annotation.Export; +import aQute.bnd.annotation.Version; \ No newline at end of file diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderServiceTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderServiceTest.java new file mode 100644 index 0000000..98754d4 --- /dev/null +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoProviderServiceTest.java @@ -0,0 +1,92 @@ +/* + * 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.multiplex; + +import java.util.Collections; + +import com.google.common.collect.ImmutableMap; +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; +import org.apache.sling.testing.mock.osgi.MockOsgi; +import org.apache.sling.testing.mock.osgi.junit.OsgiContext; +import org.junit.Rule; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +public class MountInfoProviderServiceTest { + @Rule + public final OsgiContext context = new OsgiContext(); + + private MountInfoProviderService service = new MountInfoProviderService(); + + @Test + public void defaultSetup() throws Exception{ + MockOsgi.activate(service, context.bundleContext(), Collections.emptyMap()); + + MountInfoProvider provider = context.getService(MountInfoProvider.class); + assertNotNull(provider); + assertEquals(MountInfoProvider.DEFAULT, provider); + + MockOsgi.deactivate(service); + assertNull(context.getService(MountInfoProvider.class)); + } + + @Test + public void mountWithConfig_Paths() throws Exception{ + MockOsgi.activate(service, context.bundleContext(), + ImmutableMap.of("mountedPaths", new String[] {"/a", "/b"})); + + MountInfoProvider provider = context.getService(MountInfoProvider.class); + assertEquals(1, provider.getNonDefaultMounts().size()); + + Mount m = provider.getMountByName(MountInfoProviderService.PROP_MOUNT_NAME_DEFAULT); + assertNotNull(m); + assertFalse(m.isReadOnly()); + assertEquals(m, provider.getMountByPath("/a")); + assertEquals(Mount.DEFAULT, provider.getMountByPath("/x")); + } + + @Test + public void mountWithConfig_Name() throws Exception{ + MockOsgi.activate(service, context.bundleContext(), + ImmutableMap.of( + "mountedPaths", new String[] {"/a", "/b"}, + "mountName", "foo", + "readOnlyMount", true + )); + + MountInfoProvider provider = context.getService(MountInfoProvider.class); + assertEquals(1, provider.getNonDefaultMounts().size()); + + Mount m = provider.getMountByName(MountInfoProviderService.PROP_MOUNT_NAME_DEFAULT); + assertNull(m); + + m = provider.getMountByName("foo"); + assertEquals(m, provider.getMountByPath("/a")); + assertEquals(Mount.DEFAULT, provider.getMountByPath("/x")); + assertTrue(m.isReadOnly()); + } + +} \ No newline at end of file diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoTest.java new file mode 100644 index 0000000..9b4d77a --- /dev/null +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/MountInfoTest.java @@ -0,0 +1,40 @@ +/* + * 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.multiplex; + +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.junit.Test; + +import static com.google.common.collect.ImmutableList.of; +import static org.junit.Assert.*; + +public class MountInfoTest { + + @Test + public void mountNameInPath() throws Exception{ + MountInfo md = new MountInfo(new Mount("foo"), of("/a", "/b")); + assertTrue(md.isMounted("/a")); + assertTrue(md.isMounted("/b")); + assertTrue(md.isMounted("/b/c/d")); + assertTrue("dynamic mount path not recognized", md.isMounted("/x/y/oak:foo/a")); + assertFalse(md.isMounted("/x/y")); + assertFalse(md.isMounted("/x/y/foo")); + } +} \ No newline at end of file diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProviderTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProviderTest.java new file mode 100644 index 0000000..8135544 --- /dev/null +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/multiplex/SimpleMountInfoProviderTest.java @@ -0,0 +1,99 @@ +/* + * 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.multiplex; + +import java.util.Collection; +import java.util.Collections; + +import org.apache.jackrabbit.oak.spi.mount.Mount; +import org.apache.jackrabbit.oak.spi.mount.MountInfoProvider; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +public class SimpleMountInfoProviderTest { + @Test + public void defaultMount() throws Exception { + MountInfoProvider mip = new SimpleMountInfoProvider(Collections.emptyList()); + + assertNotNull(mip.getMountByPath("/a")); + assertTrue(mip.getMountByPath("/a").isDefault()); + assertFalse(mip.hasNonDefaultMounts()); + } + + @Test + public void basicMounting() throws Exception { + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .mount("bar", "/x", "/y") + .build(); + + assertEquals("foo", mip.getMountByPath("/a").getName()); + assertEquals("foo", mip.getMountByPath("/a/x").getName()); + assertEquals("bar", mip.getMountByPath("/x").getName()); + assertTrue(mip.getMountByPath("/z").isDefault()); + assertTrue(mip.hasNonDefaultMounts()); + } + + @Test + public void nonDefaultMounts() throws Exception{ + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .mount("bar", "/x", "/y") + .build(); + + Collection mounts = mip.getNonDefaultMounts(); + assertEquals(2, mounts.size()); + assertFalse(mounts.contains(Mount.DEFAULT)); + + assertNotNull(mip.getMountByName("foo")); + assertNotNull(mip.getMountByName("bar")); + assertNull(mip.getMountByName("boom")); + } + + @Test + public void readOnlyMounting() throws Exception{ + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("foo", "/a", "/b") + .readOnlyMount("bar", "/x", "/y") + .build(); + + assertTrue(mip.getMountByName("bar").isReadOnly()); + assertFalse(mip.getMountByName("foo").isReadOnly()); + } + + @Test + public void mountsPlacedUnder() { + + MountInfoProvider mip = SimpleMountInfoProvider.newBuilder() + .mount("first", "/b") + .mount("second", "/d", "/b/a") + .mount("third", "/h", "/b/c") + .build(); + + Collection mountsContainedBetweenPaths = mip.getMountsPlacedUnder("/b"); + + assertEquals(2, mountsContainedBetweenPaths.size()); + } +} \ No newline at end of file