| /* |
| * 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.ignite.internal.processors.igfs; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.nio.file.Files; |
| import java.util.Collection; |
| import java.util.concurrent.atomic.AtomicLong; |
| import org.apache.ignite.IgniteSystemProperties; |
| import org.apache.ignite.igfs.IgfsFile; |
| import org.apache.ignite.igfs.IgfsMode; |
| import org.apache.ignite.igfs.IgfsPath; |
| import org.apache.ignite.igfs.secondary.IgfsSecondaryFileSystem; |
| import org.apache.ignite.igfs.secondary.local.LocalIgfsSecondaryFileSystem; |
| import org.apache.ignite.internal.util.typedef.F; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| import org.apache.ignite.lang.IgniteBiInClosure; |
| import org.jetbrains.annotations.Nullable; |
| import org.junit.Test; |
| |
| /** |
| * Abstract test for Hadoop 1.0 file system stack. |
| */ |
| public abstract class IgfsLocalSecondaryFileSystemDualAbstractSelfTest extends IgfsDualAbstractSelfTest { |
| /** */ |
| private static final String FS_WORK_DIR = U.getIgniteHome() + File.separatorChar + "work" |
| + File.separatorChar + "fs"; |
| |
| /** */ |
| private static final String FS_EXT_DIR = U.getIgniteHome() + File.separatorChar + "work" |
| + File.separatorChar + "ext"; |
| |
| /** */ |
| private final File dirLinkDest = new File(FS_EXT_DIR + File.separatorChar + "extdir"); |
| |
| /** */ |
| private final File fileLinkDest = |
| new File(FS_EXT_DIR + File.separatorChar + "extdir" + File.separatorChar + "filedest"); |
| |
| /** */ |
| private final File dirLinkSrc = new File(FS_WORK_DIR + File.separatorChar + "dir"); |
| |
| /** */ |
| private final File fileLinkSrc = new File(FS_WORK_DIR + File.separatorChar + "file"); |
| |
| /** */ |
| private final String TEST_GROUP = System.getProperty("IGFS_LOCAL_FS_TEST_GROUP", "igfs_grp_0"); |
| |
| /** */ |
| private final Boolean PROPERTIES_SUPPORT = |
| IgniteSystemProperties.getBoolean("IGFS_LOCAL_FS_PROPERTIES_SUPPORT", false); |
| |
| /** |
| * Constructor. |
| * |
| * @param mode IGFS mode. |
| */ |
| protected IgfsLocalSecondaryFileSystemDualAbstractSelfTest(IgfsMode mode) { |
| super(mode); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override protected void beforeTest() throws Exception { |
| super.beforeTest(); |
| |
| final File extDir = new File(FS_EXT_DIR); |
| |
| if (!extDir.exists()) |
| assert extDir.mkdirs(); |
| else |
| cleanDirectory(extDir); |
| } |
| |
| /** |
| * Creates secondary filesystems. |
| * @return IgfsSecondaryFileSystem |
| * @throws Exception On failure. |
| */ |
| @Override protected IgfsSecondaryFileSystem createSecondaryFileSystemStack() throws Exception { |
| final File workDir = new File(FS_WORK_DIR); |
| |
| if (!workDir.exists()) |
| assert workDir.mkdirs(); |
| |
| LocalIgfsSecondaryFileSystem second = new LocalIgfsSecondaryFileSystem(); |
| |
| second.setWorkDirectory(workDir.getAbsolutePath()); |
| |
| igfsSecondary = new IgfsLocalSecondaryFileSystemTestAdapter(workDir); |
| |
| return second; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override protected boolean propertiesSupported() { |
| return !U.isWindows() && PROPERTIES_SUPPORT; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override protected boolean permissionsSupported() { |
| return !U.isWindows(); |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| @SuppressWarnings("ConstantConditions") |
| @Test |
| public void testListPathForSymlink() throws Exception { |
| if (U.isWindows()) |
| return; |
| |
| createSymlinks(); |
| |
| assertTrue(igfs.info(DIR).isDirectory()); |
| |
| Collection<IgfsPath> pathes = igfs.listPaths(DIR); |
| Collection<IgfsFile> files = igfs.listFiles(DIR); |
| |
| assertEquals(1, pathes.size()); |
| assertEquals(1, files.size()); |
| |
| assertEquals("filedest", F.first(pathes).name()); |
| assertEquals("filedest", F.first(files).path().name()); |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testDeleteSymlinkDir() throws Exception { |
| if (U.isWindows()) |
| return; |
| |
| createSymlinks(); |
| |
| // Only symlink must be deleted. Destination content must be exist. |
| igfs.delete(DIR, true); |
| |
| assertTrue(fileLinkDest.exists()); |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testSymlinkToFile() throws Exception { |
| if (U.isWindows()) |
| return; |
| |
| createSymlinks(); |
| |
| checkFileContent(igfs, new IgfsPath("/file"), chunk); |
| } |
| |
| /** |
| * Test update when parent is the root and the path being updated is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| @Override public void testUpdateParentRootPathMissing() throws Exception { |
| doUpdateParentRootPathMissing(properties(TEST_GROUP, "0555")); |
| } |
| |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testMkdirsInsideSymlink() throws Exception { |
| if (U.isWindows()) |
| return; |
| |
| createSymlinks(); |
| |
| igfs.mkdirs(SUBSUBDIR); |
| |
| assertTrue(Files.isDirectory(dirLinkDest.toPath().resolve("subdir/subsubdir"))); |
| assertTrue(Files.isDirectory(dirLinkSrc.toPath().resolve("subdir/subsubdir"))); |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| @Test |
| public void testUsedSpaceSize() throws Exception { |
| final int DIRS_COUNT = 5; |
| final int DIRS_MAX_DEEP = 3; |
| final int FILES_COUNT = 10; |
| final AtomicLong totalSize = new AtomicLong(); |
| |
| IgniteBiInClosure<Integer, IgfsPath> createHierarchy = new IgniteBiInClosure<Integer, IgfsPath>() { |
| @Override public void apply(Integer level, IgfsPath levelDir) { |
| try { |
| for (int i = 0; i < FILES_COUNT; ++i) { |
| IgfsPath filePath = new IgfsPath(levelDir, "file" + Integer.toString(i)); |
| |
| createFile(igfs, filePath, true, chunk); |
| |
| totalSize.getAndAdd(chunk.length); |
| } |
| |
| if (level < DIRS_MAX_DEEP) { |
| for (int dir = 0; dir < DIRS_COUNT; dir++) { |
| IgfsPath dirPath = new IgfsPath(levelDir, "dir" + Integer.toString(dir)); |
| |
| igfs.mkdirs(dirPath); |
| |
| apply(level + 1, dirPath); |
| } |
| } |
| } catch (Exception e) { |
| fail(e.getMessage()); |
| } |
| } |
| }; |
| |
| createHierarchy.apply(1, new IgfsPath("/dir")); |
| |
| assertEquals(totalSize.get(), igfs.metrics().secondarySpaceSize()); |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| private void createSymlinks() throws Exception { |
| assert dirLinkDest.mkdir(); |
| |
| createFile(fileLinkDest, true, chunk); |
| |
| Files.createSymbolicLink(dirLinkSrc.toPath(), dirLinkDest.toPath()); |
| Files.createSymbolicLink(fileLinkSrc.toPath(), fileLinkDest.toPath()); |
| } |
| |
| /** |
| * @param dir Directory to clean. |
| */ |
| private static void cleanDirectory(File dir) { |
| File[] entries = dir.listFiles(); |
| |
| if (entries != null) { |
| for (File entry : entries) { |
| if (entry.isDirectory()) { |
| cleanDirectory(entry); |
| |
| assert entry.delete(); |
| } |
| else |
| assert entry.delete(); |
| } |
| } |
| } |
| |
| /** |
| * @param f File object. |
| * @param overwrite Overwrite flag. |
| * @param chunks File content. |
| * @throws IOException If failed. |
| */ |
| private static void createFile(File f, boolean overwrite, @Nullable byte[]... chunks) throws IOException { |
| OutputStream os = null; |
| |
| try { |
| os = new FileOutputStream(f, overwrite); |
| |
| writeFileChunks(os, chunks); |
| } |
| finally { |
| U.closeQuiet(os); |
| } |
| } |
| } |