| /* |
| * 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 org.apache.ignite.IgniteException; |
| 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.internal.IgniteInternalFuture; |
| import org.apache.ignite.internal.util.typedef.F; |
| import org.apache.ignite.internal.util.typedef.T2; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.CyclicBarrier; |
| |
| import static org.apache.ignite.igfs.IgfsMode.DUAL_ASYNC; |
| import static org.apache.ignite.igfs.IgfsMode.DUAL_SYNC; |
| import static org.apache.ignite.igfs.IgfsMode.PROXY; |
| |
| /** |
| * Tests for IGFS working in mode when remote file system exists: DUAL_SYNC, DUAL_ASYNC. |
| */ |
| @SuppressWarnings("ConstantConditions") |
| public abstract class IgfsDualAbstractSelfTest extends IgfsAbstractSelfTest { |
| /** |
| * Constructor. |
| * |
| * @param mode IGFS mode. |
| */ |
| protected IgfsDualAbstractSelfTest(IgfsMode mode) { |
| super(mode); |
| } |
| |
| /** |
| * Test existence check when the path exists only remotely. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testExistsPathMissing() throws Exception { |
| create(igfsSecondary, paths(DIR), null); |
| |
| assert igfs.exists(DIR); |
| } |
| |
| /** |
| * Test list files routine when the path doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testListFilesPathMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), paths(FILE)); |
| |
| Collection<IgfsFile> paths = igfs.listFiles(SUBDIR); |
| |
| assert paths != null; |
| assert paths.size() == 2; |
| |
| Iterator<IgfsFile> iter = paths.iterator(); |
| |
| IgfsFile path1 = iter.next(); |
| IgfsFile path2 = iter.next(); |
| |
| assert (SUBSUBDIR.equals(path1.path()) && FILE.equals(path2.path())) || |
| (FILE.equals(path1.path()) && SUBSUBDIR.equals(path2.path())); |
| } |
| |
| /** |
| * Test info routine when the path doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testInfoPathMissing() throws Exception { |
| create(igfsSecondary, paths(DIR), null); |
| create(igfs, null, null); |
| |
| IgfsFile info = igfs.info(DIR); |
| |
| assert info != null; |
| |
| assertEquals(DIR, info.path()); |
| } |
| |
| /** |
| * Test rename in case source exists partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameFileSourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(FILE, FILE2); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, FILE2); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test rename in case source doesn't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameFileSourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.rename(FILE, FILE2); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, FILE2); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file rename when parent folder is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameFileParentRootSourceMissing() throws Exception { |
| IgfsPath file1 = new IgfsPath("/file1"); |
| IgfsPath file2 = new IgfsPath("/file2"); |
| |
| create(igfsSecondary, null, paths(file1)); |
| create(igfs, null, null); |
| |
| igfs.rename(file1, file2); |
| |
| checkExist(igfs, igfsSecondary, file2); |
| checkNotExist(igfs, igfsSecondary, file1); |
| } |
| |
| /** |
| * Test rename in case source exists partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameDirectorySourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(SUBDIR, SUBDIR2); |
| |
| checkExist(igfs, igfsSecondary, SUBDIR2); |
| checkNotExist(igfs, igfsSecondary, SUBDIR); |
| } |
| |
| /** |
| * Test rename in case source doesn't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameDirectorySourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| igfs.rename(SUBDIR, SUBDIR2); |
| |
| checkExist(igfs, DIR); |
| checkExist(igfs, igfsSecondary, SUBDIR2); |
| checkNotExist(igfs, igfsSecondary, SUBDIR); |
| } |
| |
| /** |
| * Test directory rename when parent folder is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testRenameDirectoryParentRootSourceMissing() throws Exception { |
| IgfsPath dir1 = new IgfsPath("/dir1"); |
| IgfsPath dir2 = new IgfsPath("/dir2"); |
| |
| create(igfsSecondary, paths(dir1), null); |
| create(igfs, null, null); |
| |
| igfs.rename(dir1, dir2); |
| |
| checkExist(igfs, igfsSecondary, dir2); |
| checkNotExist(igfs, igfsSecondary, dir1); |
| } |
| |
| /** |
| * Test move in case source exists partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move in case source doesn't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move in case destination exists partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, SUBDIR, DIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move in case destination doesn't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, SUBDIR), paths(FILE)); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move in case source and destination exist partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceAndDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, DIR_NEW), null); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move in case source and destination don't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceAndDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.rename(FILE, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move when destination is the root and source is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileDestinationRootSourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(FILE, IgfsPath.ROOT); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath("/" + FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move when destination is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileDestinationRootSourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.rename(FILE, IgfsPath.ROOT); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath("/" + FILE.name())); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move when source parent is the root and the source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceParentRootSourceMissing() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(file, SUBDIR_NEW); |
| |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test file move when source parent is the root and destination is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceParentRootDestinationMissingPartially() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, paths(DIR_NEW), null); |
| |
| igfs.rename(file, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test file move when source parent is the root and destination is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveFileSourceParentRootDestinationMissing() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, null, null); |
| |
| igfs.rename(file, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, FILE.name())); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test move and rename in case source exists partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move and rename in case source doesn't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move and rename in case destination exists partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, SUBDIR, DIR_NEW), paths(FILE)); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move and rename in case destination doesn't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, SUBDIR), paths(FILE)); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move and rename in case source and destination exist partially and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceAndDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, paths(DIR, DIR_NEW), null); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, SUBDIR, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test move and rename in case source and destination don't exist and the path being renamed is a file. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceAndDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW, SUBDIR_NEW), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.rename(FILE, FILE_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move and rename when destination is the root and source is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileDestinationRootSourceMissingPartially() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE.name()); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(FILE, file); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, file); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move and rename when destination is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileDestinationRootSourceMissing() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE.name()); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.rename(FILE, file); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, file); |
| checkNotExist(igfs, igfsSecondary, FILE); |
| } |
| |
| /** |
| * Test file move and rename when source parent is the root and the source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceParentRootSourceMissing() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(file, FILE_NEW); |
| |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test file move and rename when source parent is the root and destination is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceParentRootDestinationMissingPartially() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, paths(DIR_NEW), null); |
| |
| igfs.rename(file, FILE_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test file move and rename when source parent is the root and destination is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameFileSourceParentRootDestinationMissing() throws Exception { |
| IgfsPath file = new IgfsPath("/" + FILE_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW), paths(file)); |
| create(igfs, null, null); |
| |
| igfs.rename(file, FILE_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, FILE_NEW); |
| checkNotExist(igfs, igfsSecondary, file); |
| } |
| |
| /** |
| * Test move in case source exists partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move in case source doesn't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR); |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move in case destination exists partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectoryDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move in case destination doesn't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectoryDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move in case source and destination exist partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceAndDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, DIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move in case source and destination don't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceAndDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, null, null); |
| |
| igfs.rename(SUBSUBDIR, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move when destination is the root and source is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectoryDestinationRootSourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(SUBSUBDIR, IgfsPath.ROOT); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath("/" + SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move when destination is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectoryDestinationRootSourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| create(igfs, null, null); |
| |
| igfs.rename(SUBSUBDIR, IgfsPath.ROOT); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, new IgfsPath("/" + SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move when source parent is the root and the source folder is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceParentRootSourceMissing() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(dir, SUBDIR_NEW); |
| |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test directory move when source parent is the root and destination is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceParentRootDestinationMissingPartially() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, paths(DIR_NEW), null); |
| |
| igfs.rename(dir, SUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test directory move when source parent is the root and destination is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveDirectorySourceParentRootDestinationMissing() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, null, null); |
| |
| igfs.rename(dir, SUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, new IgfsPath(SUBDIR_NEW, SUBSUBDIR.name())); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test move and rename in case source exists partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move and rename in case source doesn't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, DIR); |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move and rename in case destination exists partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectoryDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move and rename in case destination doesn't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectoryDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move and rename in case source and destination exist partially and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceAndDestinationMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, paths(DIR, DIR_NEW), null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test move and rename in case source and destination don't exist and the path being renamed is a directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceAndDestinationMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR, DIR_NEW, SUBDIR_NEW), null); |
| create(igfs, null, null); |
| |
| igfs.rename(SUBSUBDIR, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, DIR, SUBDIR, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move and rename when destination is the root and source is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectoryDestinationRootSourceMissingPartially() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR.name()); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| igfs.rename(SUBSUBDIR, dir); |
| |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, dir); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move and rename when destination is the root and source is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectoryDestinationRootSourceMissing() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR.name()); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), null); |
| create(igfs, null, null); |
| |
| igfs.rename(SUBSUBDIR, dir); |
| |
| checkExist(igfs, DIR, SUBDIR); |
| checkExist(igfs, igfsSecondary, dir); |
| checkNotExist(igfs, igfsSecondary, SUBSUBDIR); |
| } |
| |
| /** |
| * Test directory move and rename when source parent is the root and the source is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceParentRootSourceMissing() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, paths(DIR_NEW, SUBDIR_NEW), null); |
| |
| igfs.rename(dir, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test directory move and rename when source parent is the root and destination is missing partially. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceParentRootDestinationMissingPartially() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, paths(DIR_NEW), null); |
| |
| igfs.rename(dir, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test directory move and rename when source parent is the root and destination is missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMoveRenameDirectorySourceParentRootDestinationMissing() throws Exception { |
| IgfsPath dir = new IgfsPath("/" + SUBSUBDIR_NEW.name()); |
| |
| create(igfsSecondary, paths(DIR_NEW, SUBDIR_NEW, dir), null); |
| create(igfs, null, null); |
| |
| igfs.rename(dir, SUBSUBDIR_NEW); |
| |
| checkExist(igfs, DIR_NEW, SUBDIR_NEW); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, dir); |
| } |
| |
| /** |
| * Test mkdirs in case parent exists remotely, but some part of the parent path doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMkdirsParentPathMissingPartially() throws Exception { |
| Map<String, String> props = null; |
| |
| if (permissionsSupported()) |
| props = properties(null, null, "0555"); // mkdirs command doesn't propagate user info. |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| igfs.mkdirs(SUBSUBDIR, props); |
| |
| // Ensure that directory was created and properties are propagated. |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR); |
| |
| if (permissionsSupported()) { |
| // Check only permissions because user and group will always be present in Hadoop secondary filesystem. |
| assertEquals(props.get(IgfsUtils.PROP_PERMISSION), igfsSecondary.permissions(SUBSUBDIR.toString())); |
| |
| // We check only permission because IGFS client adds username and group name explicitly. |
| assertEquals(props.get(IgfsUtils.PROP_PERMISSION), |
| igfs.info(SUBSUBDIR).properties().get(IgfsUtils.PROP_PERMISSION)); |
| } |
| } |
| |
| /** |
| * Test mkdirs in case parent exists remotely, but no parents exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testMkdrisParentPathMissing() throws Exception { |
| Map<String, String> props = null; |
| |
| if (permissionsSupported()) |
| props = properties(null, null, "0555"); // mkdirs command doesn't propagate user info. |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| igfs.mkdirs(SUBSUBDIR, props); |
| |
| // Ensure that directory was created and properties are propagated. |
| checkExist(igfs, DIR); |
| checkExist(igfs, SUBDIR); |
| checkExist(igfs, igfsSecondary, SUBSUBDIR); |
| |
| if (permissionsSupported()) { |
| // Check only permission because in case of Hadoop secondary Fs user and group will always be present: |
| assertEquals(props.get(IgfsUtils.PROP_PERMISSION), igfsSecondary.permissions(SUBSUBDIR.toString())); |
| |
| // We check only permission because IGFS client adds username and group name explicitly. |
| assertEquals(props.get(IgfsUtils.PROP_PERMISSION), |
| igfs.info(SUBSUBDIR).properties().get(IgfsUtils.PROP_PERMISSION)); |
| } |
| } |
| |
| /** |
| * Test delete in case parent exists remotely, but some part of the parent path doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testDeletePathMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), paths(FILE)); |
| create(igfs, paths(DIR), null); |
| |
| igfs.delete(SUBDIR, true); |
| |
| checkExist(igfs, DIR); |
| checkNotExist(igfs, igfsSecondary, SUBDIR, SUBSUBDIR, FILE); |
| } |
| |
| /** |
| * Test delete in case parent exists remotely, but no parents exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testDeletePathMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.delete(SUBDIR, true); |
| |
| checkExist(igfs, DIR); |
| checkNotExist(igfs, igfsSecondary, SUBDIR, SUBSUBDIR, FILE); |
| } |
| |
| /** |
| * Test delete when the path parent is the root and the path is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testDeleteParentRootPathMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| igfs.delete(DIR, true); |
| |
| checkNotExist(igfs, igfsSecondary, DIR, SUBDIR, SUBSUBDIR, FILE); |
| } |
| |
| /** |
| * Test update in case file exists remotely, but some part of the path doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testUpdatePathMissingPartially() throws Exception { |
| if(!propertiesSupported()) |
| return; |
| |
| Map<String, String> propsSubDir = properties("subDirOwner", "subDirGroup", "0555"); |
| Map<String, String> propsFile = properties("fileOwner", "fileGroup", "0666"); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, paths(DIR), null); |
| |
| // Set different properties to the sub-directory. |
| igfsSecondaryFileSystem.update(SUBDIR, propsSubDir); |
| |
| igfs.update(FILE, propsFile); |
| |
| // Ensure missing entries were re-created locally. |
| checkExist(igfs, SUBDIR, FILE); |
| |
| // Ensure properties propagation. |
| assertEquals(propsSubDir, igfsSecondary.properties(SUBDIR.toString())); |
| assertEquals(propsSubDir, igfs.info(SUBDIR).properties()); |
| |
| assertEquals(propsFile, igfsSecondary.properties(FILE.toString())); |
| assertEquals(propsFile, igfs.info(FILE).properties()); |
| } |
| |
| /** |
| * Test update in case file exists remotely, but neither the file nor all it's parents exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testUpdatePathMissing() throws Exception { |
| if(!propertiesSupported()) |
| return; |
| |
| Map<String, String> propsSubDir = properties("subDirOwner", "subDirGroup", "0555"); |
| Map<String, String> propsFile = properties("fileOwner", "fileGroup", "0666"); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE)); |
| create(igfs, null, null); |
| |
| // Set different properties to the sub-directory. |
| igfsSecondaryFileSystem.update(SUBDIR, propsSubDir); |
| |
| igfs.update(FILE, propsFile); |
| |
| // Ensure missing entries were re-created locally. |
| checkExist(igfs, DIR, SUBDIR, FILE); |
| |
| // Ensure properties propagation. |
| assertEquals(propsSubDir, igfsSecondary.properties(SUBDIR.toString())); |
| assertEquals(propsSubDir, igfs.info(SUBDIR).properties()); |
| |
| assertEquals(propsFile, igfsSecondary.properties(FILE.toString())); |
| assertEquals(propsFile, igfs.info(FILE).properties()); |
| } |
| |
| /** |
| * Test update when parent is the root and the path being updated is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testUpdateParentRootPathMissing() throws Exception { |
| doUpdateParentRootPathMissing(properties("owner", "group", "0555")); |
| } |
| |
| /** |
| * Test update when parent is the root and the path being updated is missing locally. |
| * |
| * @param props Properties. |
| * @throws Exception If failed. |
| */ |
| protected void doUpdateParentRootPathMissing(Map<String, String> props) throws Exception { |
| if (!propertiesSupported()) |
| return; |
| |
| create(igfsSecondary, paths(DIR), null); |
| create(igfs, null, null); |
| |
| igfs.update(DIR, props); |
| |
| checkExist(igfs, DIR); |
| |
| assertTrue(propertiesContains(igfsSecondary.properties(DIR.toString()), props)); |
| assertTrue(propertiesContains(igfs.info(DIR).properties(), props)); |
| } |
| |
| /** |
| * Test file open in case it doesn't exist locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testOpenMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| createFile(igfsSecondary, FILE, chunk); |
| |
| checkFileContent(igfs, FILE, chunk); |
| } |
| |
| /** |
| * Test create when parent directory is partially missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testCreateParentMissingPartially() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| createFile(igfs, FILE, true, chunk); |
| |
| // Ensure that directory structure was created. |
| checkExist(igfs, igfsSecondary, SUBDIR); |
| checkFile(igfs, igfsSecondary, FILE, chunk); |
| } |
| |
| /** |
| * Test properties set on partially missing directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testSetPropertiesOnPartiallyMissingDirectory() throws Exception { |
| if (!propertiesSupported()) |
| return; |
| |
| Map<String, String> props = properties("owner", "group", "0555"); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| igfsSecondaryFileSystem.update(SUBDIR, props); |
| |
| // Ensure properties propagation of the created subdirectory. |
| assertEquals(props, igfs.info(SUBDIR).properties()); |
| } |
| |
| /** |
| * Test create when parent directory is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testCreateParentMissing() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| createFile(igfs, FILE, true, chunk); |
| |
| checkExist(igfs, igfsSecondary, SUBDIR); |
| checkFile(igfs, igfsSecondary, FILE, chunk); |
| } |
| |
| /** |
| * Test properties set on missing directory. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testSetPropertiesOnMissingDirectory() throws Exception { |
| if (!propertiesSupported()) |
| return; |
| |
| Map<String, String> propsDir = properties("ownerDir", "groupDir", "0555"); |
| Map<String, String> propsSubDir = properties("ownerSubDir", "groupSubDir", "0666"); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| igfsSecondaryFileSystem.update(DIR, propsDir); |
| igfsSecondaryFileSystem.update(SUBDIR, propsSubDir); |
| |
| // Ensure properties propagation of the created directories. |
| assertEquals(propsDir, igfs.info(DIR).properties()); |
| assertEquals(propsSubDir, igfs.info(SUBDIR).properties()); |
| } |
| |
| /** |
| * Test append when parent directory is partially missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testAppendParentMissingPartially() throws Exception { |
| if (!appendSupported()) |
| return; |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, paths(DIR), null); |
| |
| createFile(igfsSecondary, FILE, /*BLOCK_SIZE,*/ chunk); |
| |
| appendFile(igfs, FILE, chunk); |
| |
| // Ensure that directory structure was created. |
| checkExist(igfs, igfsSecondary, SUBDIR); |
| checkFile(igfs, igfsSecondary, FILE, chunk, chunk); |
| } |
| |
| /** |
| * Test append when parent directory is missing locally. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testAppendParentMissing() throws Exception { |
| if (!appendSupported()) |
| return; |
| |
| create(igfsSecondary, paths(DIR, SUBDIR), null); |
| create(igfs, null, null); |
| |
| createFile(igfsSecondary, FILE, /*BLOCK_SIZE,*/ chunk); |
| |
| appendFile(igfs, FILE, chunk); |
| |
| checkExist(igfs, igfsSecondary, SUBDIR); |
| checkFile(igfs, igfsSecondary, FILE, chunk, chunk); |
| } |
| |
| /** |
| * Ensure that in case we rename the folder A and delete it at the same time, only one of these requests succeed. |
| * Initially file system entries are created only in the secondary file system. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testConcurrentRenameDeleteSourceRemote() throws Exception { |
| for (int i = 0; i < REPEAT_CNT; i++) { |
| final CyclicBarrier barrier = new CyclicBarrier(2); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW), paths()); |
| |
| IgniteInternalFuture<Boolean> res1 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.rename(SUBDIR, SUBDIR_NEW); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| IgniteInternalFuture<Boolean> res2 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| return igfs.delete(SUBDIR, true); |
| } |
| }); |
| |
| res1.get(); |
| res2.get(); |
| |
| if (res1.get()) { |
| assert !res2.get(); // Rename succeeded, so delete must fail. |
| |
| checkExist(igfs, igfsSecondary, DIR, DIR_NEW, SUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR); |
| } |
| else { |
| assert res2.get(); // Rename failed because delete succeeded. |
| |
| checkExist(igfs, DIR); // DIR_NEW should not be synchronized with he primary IGFS. |
| checkExist(igfsSecondary, DIR, DIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR, SUBDIR_NEW); |
| } |
| |
| clear(igfs, igfsSecondary); |
| } |
| } |
| |
| /** |
| * Ensure that in case we rename the folder A to B and delete B at the same time, FS consistency is not compromised. |
| * Initially file system entries are created only in the secondary file system. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testConcurrentRenameDeleteDestinationRemote() throws Exception { |
| for (int i = 0; i < REPEAT_CNT; i++) { |
| final CyclicBarrier barrier = new CyclicBarrier(2); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW), paths()); |
| |
| IgniteInternalFuture<Boolean> res1 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.rename(SUBDIR, SUBDIR_NEW); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| IgniteInternalFuture<Boolean> res2 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| return igfs.delete(SUBDIR_NEW, true); |
| } |
| }); |
| |
| assert res1.get(); |
| |
| if (res2.get()) { |
| // Delete after rename. |
| checkExist(igfs, igfsSecondary, DIR, DIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR, SUBDIR_NEW); |
| } |
| else { |
| // Delete before rename. |
| checkExist(igfs, igfsSecondary, DIR, DIR_NEW, SUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR); |
| } |
| |
| clear(igfs, igfsSecondary); |
| } |
| } |
| |
| /** |
| * Ensure file system consistency in case two concurrent rename requests are executed: A -> B and B -> A. |
| * Initially file system entries are created only in the secondary file system. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testConcurrentRenamesRemote() throws Exception { |
| for (int i = 0; i < REPEAT_CNT; i++) { |
| final CyclicBarrier barrier = new CyclicBarrier(2); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, DIR_NEW), paths()); |
| |
| IgniteInternalFuture<Boolean> res1 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.rename(SUBDIR, SUBDIR_NEW); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| IgniteInternalFuture<Boolean> res2 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.rename(SUBDIR_NEW, SUBDIR); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| res1.get(); |
| res2.get(); |
| |
| assert res1.get(); // First rename must be successful anyway. |
| |
| if (res2.get()) { |
| checkExist(igfs, igfsSecondary, DIR, SUBDIR, DIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR_NEW); |
| } |
| else { |
| checkExist(igfs, igfsSecondary, DIR, DIR_NEW, SUBDIR_NEW); |
| checkNotExist(igfs, igfsSecondary, SUBDIR); |
| } |
| |
| clear(igfs, igfsSecondary); |
| } |
| } |
| |
| /** |
| * Ensure that in case we delete the folder A and delete its parent at the same time, resulting file system |
| * structure is consistent. Initially file system entries are created only in the secondary file system. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testConcurrentDeletesRemote() throws Exception { |
| for (int i = 0; i < REPEAT_CNT; i++) { |
| final CyclicBarrier barrier = new CyclicBarrier(2); |
| |
| create(igfsSecondary, paths(DIR, SUBDIR, SUBSUBDIR), paths()); |
| |
| IgniteInternalFuture<Boolean> res1 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.delete(SUBDIR, true); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| IgniteInternalFuture<Boolean> res2 = execute(new Callable<Boolean>() { |
| @Override public Boolean call() throws Exception { |
| U.awaitQuiet(barrier); |
| |
| try { |
| igfs.delete(SUBSUBDIR, true); |
| |
| return true; |
| } |
| catch (IgniteException ignored) { |
| return false; |
| } |
| } |
| }); |
| |
| assert res1.get(); // Delete on the parent must succeed anyway. |
| res2.get(); |
| |
| checkExist(igfs, igfsSecondary, DIR); |
| checkNotExist(igfs, igfsSecondary, SUBDIR, SUBSUBDIR); |
| |
| clear(igfs, igfsSecondary); |
| } |
| } |
| |
| /** |
| * Checks file access & modification time equality in the file itself and in the same file found through |
| * the listing of its parent. |
| * |
| * @param fs The file system. |
| * @param p The file path. |
| * |
| * @return Tuple of access and modification times of the file. |
| */ |
| private T2<Long, Long> checkParentListingTime(IgfsSecondaryFileSystem fs, IgfsPath p) { |
| IgfsFile f0 = fs.info(p); |
| |
| T2<Long, Long> t0 = new T2<>(f0.accessTime(), f0.modificationTime()); |
| |
| // Root cannot be seen through the parent listing: |
| if (!F.eq(IgfsPath.ROOT, p)) { |
| assertNotNull(f0); |
| |
| Collection<IgfsFile> listing = fs.listFiles(p.parent()); |
| |
| IgfsFile f1 = null; |
| |
| for (IgfsFile fi : listing) { |
| if (F.eq(fi.path(), p)) { |
| f1 = fi; |
| |
| break; |
| } |
| } |
| |
| assertNotNull(f1); // file should be found in parent listing. |
| |
| T2<Long, Long> t1 = new T2<>(f1.accessTime(), f1.modificationTime()); |
| |
| assertEquals(t0, t1); |
| } |
| |
| return t0; |
| } |
| |
| /** |
| * Test for file modification time upwards propagation when files are |
| * created on the secondary file system and initially |
| * unknown on the primary file system. |
| * |
| * @throws Exception On error. |
| */ |
| public void testAccessAndModificationTimeUpwardsPropagation() throws Exception { |
| create(igfsSecondary, paths(DIR, SUBDIR), paths(FILE, FILE2)); |
| |
| T2<Long,Long> timesDir0 = checkParentListingTime(igfsSecondaryFileSystem, DIR); |
| T2<Long,Long> timesSubDir0 = checkParentListingTime(igfsSecondaryFileSystem, SUBDIR); |
| T2<Long,Long> timesFile0 = checkParentListingTime(igfsSecondaryFileSystem, FILE); |
| T2<Long,Long> timesFile20 = checkParentListingTime(igfsSecondaryFileSystem, FILE2); |
| |
| Thread.sleep(500L); |
| |
| T2<Long,Long> timesDir1 = checkParentListingTime(igfs.asSecondary(), DIR); |
| T2<Long,Long> timesSubDir1 = checkParentListingTime(igfs.asSecondary(), SUBDIR); |
| T2<Long,Long> timesFile1 = checkParentListingTime(igfs.asSecondary(), FILE); |
| T2<Long,Long> timesFile21 = checkParentListingTime(igfs.asSecondary(), FILE2); |
| |
| assertEquals(timesDir0, timesDir1); |
| assertEquals(timesSubDir0, timesSubDir1); |
| assertEquals(timesFile0, timesFile1); |
| assertEquals(timesFile20, timesFile21); |
| } |
| |
| /** |
| * Test setTimes method when path is partially missing. |
| * |
| * @throws Exception If failed. |
| */ |
| public void testSetTimesMissingPartially() throws Exception { |
| if (!timesSupported()) |
| return; |
| |
| create(igfs, paths(DIR, SUBDIR), null); |
| |
| createFile(igfsSecondary, FILE, chunk); |
| |
| final long MAX_ALIGN_ON_SECOND = (long)Integer.MAX_VALUE * 1000; |
| |
| igfs.setTimes(FILE, MAX_ALIGN_ON_SECOND, MAX_ALIGN_ON_SECOND - 1000); |
| |
| IgfsFile info = igfs.info(FILE); |
| |
| assert info != null; |
| |
| assertEquals(MAX_ALIGN_ON_SECOND - 1000, info.accessTime()); |
| assertEquals(MAX_ALIGN_ON_SECOND, info.modificationTime()); |
| |
| T2<Long, Long> secondaryTimes = igfsSecondary.times(FILE.toString()); |
| |
| assertEquals(info.modificationTime(), (long) secondaryTimes.get1()); |
| assertEquals(info.accessTime(), (long) secondaryTimes.get2()); |
| |
| try { |
| igfs.setTimes(FILE2, MAX_ALIGN_ON_SECOND, MAX_ALIGN_ON_SECOND); |
| |
| fail("Exception is not thrown for missing file."); |
| } catch (Exception ignore) { |
| // No-op. |
| } |
| } |
| |
| /** |
| * |
| * @throws Exception If failed. |
| */ |
| public void testSecondarySize() throws Exception { |
| igfs.mkdirs(SUBDIR); |
| |
| createFile(igfsSecondary, FILE, chunk); |
| createFile(igfsSecondary, new IgfsPath(SUBDIR, "file2"), chunk); |
| |
| assertEquals(chunk.length, igfs.size(FILE)); |
| assertEquals(chunk.length * 2, igfs.size(SUBDIR)); |
| } |
| |
| /** |
| * @param allProps All properties. |
| * @param checkedProps Checked properies |
| * @return {@code true} If allchecked properties are contained in the #propsAll. |
| */ |
| public static boolean propertiesContains(Map<String, String> allProps, Map<String, String> checkedProps) { |
| for (String name : checkedProps.keySet()) |
| if (!checkedProps.get(name).equals(allProps.get(name))) { |
| System.err.println("All properties: " + allProps); |
| System.err.println("Checked properties: " + checkedProps); |
| return false; |
| } |
| |
| return true; |
| } |
| } |
