/** Tests a file can be deleted. */
 @Test
 public void deleteFile() throws IOException {
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   createEmptyFile(testFile);
   mUfs.delete(testFile, false);
   Assert.assertFalse(mUfs.exists(testFile));
 }
 // Creates a block file and write an increasing byte array into it
 private void createBlockFile(String filename, int len) throws IOException, InvalidPathException {
   UnderFileSystem ufs = UnderFileSystem.get(filename, mMasterConfiguration);
   ufs.mkdirs(PathUtils.getParent(filename), true);
   OutputStream out = ufs.create(filename);
   out.write(BufferUtils.getIncreasingByteArray(len), 0, len);
   out.close();
 }
  // Tests that lock block returns the correct path
  @Test
  public void lockBlockTest() throws Exception {
    final int blockSize = (int) WORKER_CAPACITY_BYTES / 2;

    CreateFileOptions options =
        CreateFileOptions.defaults()
            .setBlockSizeBytes(blockSize)
            .setWriteType(WriteType.MUST_CACHE);
    FileOutStream out = mFileSystem.createFile(new AlluxioURI("/testFile"), options);
    URIStatus file = mFileSystem.getStatus(new AlluxioURI("/testFile"));

    final long blockId = BlockId.createBlockId(BlockId.getContainerId(file.getFileId()), 0);

    out.write(BufferUtils.getIncreasingByteArray(blockSize));
    out.close();

    String localPath = mBlockWorkerServiceHandler.lockBlock(blockId, SESSION_ID).getBlockPath();

    // The local path should exist
    Assert.assertNotNull(localPath);

    UnderFileSystem ufs = UnderFileSystem.get(localPath, mMasterConfiguration);
    byte[] data = new byte[blockSize];
    int bytesRead = ufs.open(localPath).read(data);

    // The data in the local file should equal the data we wrote earlier
    Assert.assertEquals(blockSize, bytesRead);
    Assert.assertTrue(BufferUtils.equalIncreasingByteArray(bytesRead, data));

    mBlockWorkerServiceHandler.unlockBlock(blockId, SESSION_ID);
  }
 /** Tests if list correctly returns file names. */
 @Test
 public void list() throws IOException {
   String testDirNonEmpty = PathUtils.concatPath(mUnderfsAddress, "testDirNonEmpty1");
   String testDirNonEmptyChildDir = PathUtils.concatPath(testDirNonEmpty, "testDirNonEmpty2");
   String testDirNonEmptyChildFile = PathUtils.concatPath(testDirNonEmpty, "testDirNonEmptyF");
   String testDirNonEmptyChildDirFile =
       PathUtils.concatPath(testDirNonEmptyChildDir, "testDirNonEmptyChildDirF");
   mUfs.mkdirs(testDirNonEmpty, false);
   mUfs.mkdirs(testDirNonEmptyChildDir, false);
   createEmptyFile(testDirNonEmptyChildFile);
   createEmptyFile(testDirNonEmptyChildDirFile);
   String[] expectedResTopDir = new String[] {"testDirNonEmpty2", "testDirNonEmptyF"};
   // Some file systems may prefix with a slash
   String[] expectedResTopDir2 = new String[] {"/testDirNonEmpty2", "/testDirNonEmptyF"};
   Arrays.sort(expectedResTopDir);
   Arrays.sort(expectedResTopDir2);
   String[] resTopDir = mUfs.list(testDirNonEmpty);
   Arrays.sort(resTopDir);
   Assert.assertTrue(
       Arrays.equals(expectedResTopDir, resTopDir)
           || Arrays.equals(expectedResTopDir2, resTopDir));
   Assert.assertTrue(
       mUfs.list(testDirNonEmptyChildDir)[0].equals("testDirNonEmptyChildDirF")
           || mUfs.list(testDirNonEmptyChildDir)[0].equals("/testDirNonEmptyChildDirF"));
 }
  // Prepare directory tree for pagination tests
  private LargeDirectoryConfig prepareLargeDirectoryTest() throws IOException {
    final String filePrefix = "a_";
    final String folderPrefix = "b_";

    String topLevelDirectory = PathUtils.concatPath(mUnderfsAddress, "topLevelDir");

    final int numFiles = 100;

    String[] children = new String[numFiles + numFiles];

    // Make top level directory
    mUfs.mkdirs(topLevelDirectory, false);

    // Make the children files
    for (int i = 0; i < numFiles; ++i) {
      children[i] = PathUtils.concatPath(topLevelDirectory, filePrefix + String.format("%04d", i));
      createEmptyFile(children[i]);
    }
    // Make the children folders
    for (int i = 0; i < numFiles; ++i) {
      children[numFiles + i] =
          PathUtils.concatPath(topLevelDirectory, folderPrefix + String.format("%04d", i));
      mUfs.mkdirs(children[numFiles + i], false);
    }

    return new LargeDirectoryConfig(topLevelDirectory, children);
  }
Exemplo n.º 6
0
 /**
  * Creates a new file output stream.
  *
  * @param path the file path
  * @param options the client options
  * @throws IOException if an I/O error occurs
  */
 public FileOutStream(AlluxioURI path, OutStreamOptions options) throws IOException {
   mUri = Preconditions.checkNotNull(path);
   mNonce = IdUtils.getRandomNonNegativeLong();
   mBlockSize = options.getBlockSizeBytes();
   mAlluxioStorageType = options.getAlluxioStorageType();
   mUnderStorageType = options.getUnderStorageType();
   mContext = FileSystemContext.INSTANCE;
   mPreviousBlockOutStreams = new LinkedList<BufferedBlockOutStream>();
   if (mUnderStorageType.isSyncPersist()) {
     updateUfsPath();
     String tmpPath = PathUtils.temporaryFileName(mNonce, mUfsPath);
     UnderFileSystem ufs = UnderFileSystem.get(tmpPath, ClientContext.getConf());
     // TODO(jiri): Implement collection of temporary files left behind by dead clients.
     mUnderStorageOutputStream = ufs.create(tmpPath, (int) mBlockSize);
   } else {
     mUfsPath = null;
     mUnderStorageOutputStream = null;
   }
   mClosed = false;
   mCanceled = false;
   mShouldCacheCurrentBlock = mAlluxioStorageType.isStore();
   mBytesWritten = 0;
   mLocationPolicy =
       Preconditions.checkNotNull(
           options.getLocationPolicy(),
           PreconditionMessage.FILE_WRITE_LOCATION_POLICY_UNSPECIFIED);
 }
 /** Tests if file creation is atomic. */
 @Test
 public void createAtomic() throws IOException {
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   OutputStream stream = mUfs.create(testFile);
   stream.write(TEST_BYTES);
   Assert.assertFalse(mUfs.exists(testFile));
   stream.close();
 }
 /** Tests {@link UnderFileSystem#rename(String, String)} works file to new location. */
 @Test
 public void renameFile() throws IOException {
   String testFileSrc = PathUtils.concatPath(mUnderfsAddress, "testFileSrc");
   String testFileDst = PathUtils.concatPath(mUnderfsAddress, "testFileDst");
   createEmptyFile(testFileSrc);
   mUfs.rename(testFileSrc, testFileDst);
   Assert.assertFalse(mUfs.exists(testFileSrc));
   Assert.assertTrue(mUfs.exists(testFileDst));
 }
 /** Tests {@link UnderFileSystem#getFileSize(String)} correctly returns the file size. */
 @Test
 public void getFileSize() throws IOException {
   String testFileEmpty = PathUtils.concatPath(mUnderfsAddress, "testFileEmpty");
   String testFileNonEmpty = PathUtils.concatPath(mUnderfsAddress, "testFileNonEmpty");
   createEmptyFile(testFileEmpty);
   createTestBytesFile(testFileNonEmpty);
   Assert.assertEquals(mUfs.getFileSize(testFileEmpty), 0);
   Assert.assertEquals(mUfs.getFileSize(testFileNonEmpty), TEST_BYTES.length);
 }
 /**
  * Tests if {@link UnderFileSystem#isFile(String)} correctly returns true for files and false
  * otherwise.
  */
 @Test
 public void isFile() throws IOException {
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   String testDir = PathUtils.concatPath(mUnderfsAddress, "testDir");
   Assert.assertFalse(mUfs.isFile(testFile));
   createEmptyFile(testFile);
   mUfs.mkdirs(testDir, false);
   Assert.assertTrue(mUfs.isFile(testFile));
   Assert.assertFalse(mUfs.isFile(testDir));
 }
 /** Tests {@link UnderFileSystem#rename(String, String)} works file to a folder if supported. */
 @Test
 public void renameFileToFolder() throws IOException {
   String testFileSrc = PathUtils.concatPath(mUnderfsAddress, "testFileSrc");
   String testFileDst = PathUtils.concatPath(mUnderfsAddress, "testDirDst");
   String testFileFinalDst = PathUtils.concatPath(testFileDst, "testFileSrc");
   createEmptyFile(testFileSrc);
   mUfs.mkdirs(testFileDst, false);
   if (mUfs.rename(testFileSrc, testFileDst)) {
     Assert.assertFalse(mUfs.exists(testFileSrc));
     Assert.assertTrue(mUfs.exists(testFileFinalDst));
   }
 }
  /** Tests if list correctly returns file or folder names for a large directory. */
  @Test
  public void listLargeDirectory() throws IOException {
    LargeDirectoryConfig config = prepareLargeDirectoryTest();
    String[] children = config.getChildren();

    // Retry for some time to allow list operation eventual consistency for S3 and GCS.
    // See http://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html and
    // https://cloud.google.com/storage/docs/consistency for more details.
    // Note: not using CommonUtils.waitFor here because we intend to sleep with a longer interval.
    String[] results = new String[] {};
    for (int i = 0; i < 20; i++) {
      results = mUfs.list(config.getTopLevelDirectory());
      if (children.length == results.length) {
        break;
      }
      CommonUtils.sleepMs(500);
    }
    Assert.assertEquals(children.length, results.length);

    Arrays.sort(results);
    for (int i = 0; i < children.length; ++i) {
      Assert.assertTrue(
          results[i].equals(
              CommonUtils.stripPrefixIfPresent(
                  children[i], PathUtils.normalizePath(config.getTopLevelDirectory(), "/"))));
    }
  }
Exemplo n.º 13
0
  /**
   * Creates a new instance of {@link FileSystemWorker}.
   *
   * @param blockWorker the block worker handle
   * @param workerId a reference to the id of this worker
   * @throws IOException if an I/O error occurs
   */
  public DefaultFileSystemWorker(BlockWorker blockWorker, AtomicReference<Long> workerId)
      throws IOException {
    super(
        Executors.newFixedThreadPool(
            3, ThreadFactoryUtils.build("file-system-worker-heartbeat-%d", true)));
    mWorkerId = workerId;
    mSessions = new Sessions();
    UnderFileSystem ufs = UnderFileSystem.get(Configuration.get(PropertyKey.UNDERFS_ADDRESS));
    mFileDataManager =
        new FileDataManager(
            Preconditions.checkNotNull(blockWorker),
            ufs,
            RateLimiter.create(Configuration.getBytes(PropertyKey.WORKER_FILE_PERSIST_RATE_LIMIT)));
    mUnderFileSystemManager = new UnderFileSystemManager();

    // Setup AbstractMasterClient
    mFileSystemMasterWorkerClient =
        new FileSystemMasterClient(NetworkAddressUtils.getConnectAddress(ServiceType.MASTER_RPC));

    // Setup session cleaner
    mSessionCleaner =
        new SessionCleaner(
            new SessionCleanupCallback() {
              /** Cleans up after sessions, to prevent zombie sessions holding ufs resources. */
              @Override
              public void cleanupSessions() {
                for (long session : mSessions.getTimedOutSessions()) {
                  mSessions.removeSession(session);
                  mUnderFileSystemManager.cleanupSession(session);
                }
              }
            });

    mServiceHandler = new FileSystemWorkerClientServiceHandler(this);
  }
Exemplo n.º 14
0
 /**
  * Gets a UFS instance from the cache if exists. Otherwise, creates a new instance and adds that
  * to the cache.
  *
  * @param path the ufs path
  * @param ufsConf the ufs configuration
  * @return the UFS instance
  */
 UnderFileSystem get(String path, Object ufsConf) {
   Key key = new Key(new AlluxioURI(path));
   UnderFileSystem cachedFs = mUnderFileSystemMap.get(key);
   if (cachedFs != null) {
     return cachedFs;
   }
   UnderFileSystem fs = UnderFileSystemRegistry.create(path, ufsConf);
   cachedFs = mUnderFileSystemMap.putIfAbsent(key, fs);
   if (cachedFs == null) {
     return fs;
   }
   try {
     fs.close();
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
   return cachedFs;
 }
 /** Tests that a file can be created and validates the data written to it. */
 @Test
 public void createOpen() throws IOException {
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   createTestBytesFile(testFile);
   byte[] buf = new byte[TEST_BYTES.length];
   int bytesRead = mUfs.open(testFile).read(buf);
   Assert.assertTrue(bytesRead == TEST_BYTES.length);
   Assert.assertTrue(Arrays.equals(buf, TEST_BYTES));
 }
 /**
  * Tests {@link UnderFileSystem#getModificationTimeMs(String)} returns a reasonably accurate time.
  */
 @Test
 public void getModTime() throws IOException {
   long slack = 1000; // Some file systems may report nearest second.
   long start = System.currentTimeMillis();
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   createTestBytesFile(testFile);
   long end = System.currentTimeMillis();
   long modTime = mUfs.getModificationTimeMs(testFile);
   Assert.assertTrue(modTime >= start - slack);
   Assert.assertTrue(modTime <= end + slack);
 }
  /** Tests if delete deletes all files or folders for a large directory. */
  @Test
  public void deleteLargeDirectory() throws IOException {
    LargeDirectoryConfig config = prepareLargeDirectoryTest();
    mUfs.delete(config.getTopLevelDirectory(), true);

    String[] children = config.getChildren();
    for (String child : children) {
      // Retry for some time to allow list operation eventual consistency for S3 and GCS.
      // See http://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html and
      // https://cloud.google.com/storage/docs/consistency for more details.
      // Note: not using CommonUtils.waitFor here because we intend to sleep with a longer interval.
      boolean childDeleted = false;
      for (int i = 0; i < 20; i++) {
        childDeleted = !mUfs.exists(child);
        if (childDeleted) {
          break;
        }
        CommonUtils.sleepMs(500);
      }
      Assert.assertTrue(childDeleted);
    }
  }
  /** Tests if list recursive correctly returns all file names in all subdirectories. */
  @Test
  public void listRecursive() throws IOException {
    String root = mUnderfsAddress;
    // TODO(andrew): Should this directory be created in LocalAlluxioCluster creation code?
    mUfs.mkdirs(root, true);
    // Empty lsr should be empty
    Assert.assertEquals(0, mUfs.listRecursive(root).length);

    // Create a tree of subdirectories and files
    String sub1 = PathUtils.concatPath(root, "sub1");
    String sub2 = PathUtils.concatPath(root, "sub2");
    String sub11 = PathUtils.concatPath(sub1, "sub11");
    String file11 = PathUtils.concatPath(sub11, "file11");
    String file2 = PathUtils.concatPath(sub2, "file2");
    String file = PathUtils.concatPath(root, "file");
    // lsr of nonexistent path should be null
    Assert.assertNull(mUfs.listRecursive(sub1));

    mUfs.mkdirs(sub1, false);
    mUfs.mkdirs(sub2, false);
    mUfs.mkdirs(sub11, false);
    createEmptyFile(file11);
    createEmptyFile(file2);
    createEmptyFile(file);

    // lsr from root should return paths relative to the root
    String[] expectedResRoot = {
      "sub1", "sub2", "sub1/sub11", "sub1/sub11/file11", "sub2/file2", "file"
    };
    String[] actualResRoot = mUfs.listRecursive(root);
    Arrays.sort(expectedResRoot);
    Arrays.sort(actualResRoot);
    Assert.assertArrayEquals(expectedResRoot, actualResRoot);

    // lsr from sub1 should return paths relative to sub1
    String[] expectedResSub1 = {"sub11", "sub11/file11"};
    String[] actualResSub1 = mUfs.listRecursive(sub1);
    Arrays.sort(expectedResSub1);
    Arrays.sort(actualResSub1);
    Assert.assertArrayEquals(expectedResSub1, actualResSub1);

    // lsr of file should be null
    Assert.assertNull(mUfs.listRecursive(file));
  }
  /**
   * Tests {@link UnderFileSystem#mkdirs(String, boolean)} correctly creates a directory. Tests
   * {@link UnderFileSystem#mkdirs(String, boolean)} correctly makes parent directories if
   * createParent is specified.
   */
  @Test
  public void mkdirs() throws IOException {
    // make sure the underfs address dir exists already
    mUfs.mkdirs(mUnderfsAddress, true);
    // empty lsr should be empty
    Assert.assertEquals(0, mUfs.listRecursive(mUnderfsAddress).length);

    String testDirTop = PathUtils.concatPath(mUnderfsAddress, "testDirTop");
    String testDir1 = PathUtils.concatPath(mUnderfsAddress, "1");
    String testDir2 = PathUtils.concatPath(testDir1, "2");
    String testDir3 = PathUtils.concatPath(testDir2, "3");
    String testDirDeep = PathUtils.concatPath(testDir3, "testDirDeep");
    mUfs.mkdirs(testDirTop, false);
    Assert.assertTrue(mUfs.exists(testDirTop));
    mUfs.mkdirs(testDirDeep, true);
    Assert.assertTrue(mUfs.exists(testDir1));
    Assert.assertTrue(mUfs.exists(testDir2));
    Assert.assertTrue(mUfs.exists(testDir3));
    Assert.assertTrue(mUfs.exists(testDirDeep));
  }
  /** Tests load metadata on list. */
  @Test
  public void loadMetadata() throws Exception {
    String dirName = "loadMetaDataRoot";

    String rootDir = PathUtils.concatPath(mUnderfsAddress, dirName);
    mUfs.mkdirs(rootDir, true);

    String rootFile1 = PathUtils.concatPath(rootDir, "file1");
    createEmptyFile(rootFile1);

    String rootFile2 = PathUtils.concatPath(rootDir, "file2");
    createEmptyFile(rootFile2);

    AlluxioURI rootAlluxioURI = new AlluxioURI("/" + dirName);
    FileSystem client = mLocalAlluxioClusterResource.get().getClient();
    client.listStatus(
        rootAlluxioURI, ListStatusOptions.defaults().setLoadMetadataType(LoadMetadataType.Always));

    try {
      client.createDirectory(rootAlluxioURI, CreateDirectoryOptions.defaults());
      Assert.fail("create is expected to fail with FileAlreadyExistsException");
    } catch (FileAlreadyExistsException e) {
      Assert.assertEquals(
          ExceptionMessage.FILE_ALREADY_EXISTS.getMessage(rootAlluxioURI), e.getMessage());
    }

    AlluxioURI file1URI = rootAlluxioURI.join("file1");
    try {
      client.createFile(file1URI, CreateFileOptions.defaults()).close();
      Assert.fail("create is expected to fail with FileAlreadyExistsException");
    } catch (FileAlreadyExistsException e) {
      Assert.assertEquals(
          ExceptionMessage.FILE_ALREADY_EXISTS.getMessage(file1URI), e.getMessage());
    }

    AlluxioURI file2URI = rootAlluxioURI.join("file2");
    try {
      client.createFile(file2URI, CreateFileOptions.defaults()).close();
      Assert.fail("create is expected to fail with FileAlreadyExistsException");
    } catch (FileAlreadyExistsException e) {
      Assert.assertEquals(
          ExceptionMessage.FILE_ALREADY_EXISTS.getMessage(file2URI), e.getMessage());
    }
  }
 private void createEmptyFile(String path) throws IOException {
   OutputStream o = mUfs.create(path);
   o.close();
 }
Exemplo n.º 22
0
  @Override
  public void close() throws IOException {
    if (mClosed) {
      return;
    }
    if (mCurrentBlockOutStream != null) {
      mPreviousBlockOutStreams.add(mCurrentBlockOutStream);
    }

    CompleteFileOptions options = CompleteFileOptions.defaults();
    if (mUnderStorageType.isSyncPersist()) {
      String tmpPath = PathUtils.temporaryFileName(mNonce, mUfsPath);
      UnderFileSystem ufs = UnderFileSystem.get(tmpPath, ClientContext.getConf());
      if (mCanceled) {
        // TODO(yupeng): Handle this special case in under storage integrations.
        mUnderStorageOutputStream.close();
        if (!ufs.exists(tmpPath)) {
          // Location of the temporary file has changed, recompute it.
          updateUfsPath();
          tmpPath = PathUtils.temporaryFileName(mNonce, mUfsPath);
        }
        ufs.delete(tmpPath, false);
      } else {
        mUnderStorageOutputStream.flush();
        mUnderStorageOutputStream.close();
        if (!ufs.exists(tmpPath)) {
          // Location of the temporary file has changed, recompute it.
          updateUfsPath();
          tmpPath = PathUtils.temporaryFileName(mNonce, mUfsPath);
        }
        if (!ufs.rename(tmpPath, mUfsPath)) {
          throw new IOException("Failed to rename " + tmpPath + " to " + mUfsPath);
        }
        options.setUfsLength(ufs.getFileSize(mUfsPath));
      }
    }

    if (mAlluxioStorageType.isStore()) {
      try {
        if (mCanceled) {
          for (BufferedBlockOutStream bos : mPreviousBlockOutStreams) {
            bos.cancel();
          }
        } else {
          for (BufferedBlockOutStream bos : mPreviousBlockOutStreams) {
            bos.close();
          }
        }
      } catch (IOException e) {
        handleCacheWriteException(e);
      }
    }

    // Complete the file if it's ready to be completed.
    if (!mCanceled && (mUnderStorageType.isSyncPersist() || mAlluxioStorageType.isStore())) {
      FileSystemMasterClient masterClient = mContext.acquireMasterClient();
      try {
        masterClient.completeFile(mUri, options);
      } catch (AlluxioException e) {
        throw new IOException(e);
      } finally {
        mContext.releaseMasterClient(masterClient);
      }
    }

    if (mUnderStorageType.isAsyncPersist()) {
      scheduleAsyncPersist();
    }
    mClosed = true;
  }
 /** Tests that an empty file can be created. */
 @Test
 public void createEmpty() throws IOException {
   String testFile = PathUtils.concatPath(mUnderfsAddress, "testFile");
   createEmptyFile(testFile);
   Assert.assertTrue(mUfs.exists(testFile));
 }
 @Before
 public final void before() throws Exception {
   Configuration.set(PropertyKey.UNDERFS_LISTING_LENGTH, 50);
   mUnderfsAddress = Configuration.get(PropertyKey.UNDERFS_ADDRESS);
   mUfs = UnderFileSystem.get(mUnderfsAddress + AlluxioURI.SEPARATOR);
 }
 private void createTestBytesFile(String path) throws IOException {
   OutputStream o = mUfs.create(path);
   o.write(TEST_BYTES);
   o.close();
 }
 /**
  * Tests an empty directory can be deleted. Tests a non empty directory will not be deleted if
  * recursive is not specified. Tests a non empty directory will be deleted if recursive is
  * specified.
  */
 @Test
 public void deleteDir() throws IOException {
   String testDirEmpty = PathUtils.concatPath(mUnderfsAddress, "testDirEmpty");
   String testDirNonEmpty = PathUtils.concatPath(mUnderfsAddress, "testDirNonEmpty1");
   String testDirNonEmptyChildDir = PathUtils.concatPath(testDirNonEmpty, "testDirNonEmpty2");
   String testDirNonEmptyChildFile = PathUtils.concatPath(testDirNonEmpty, "testDirNonEmptyF");
   String testDirNonEmptyChildDirFile =
       PathUtils.concatPath(testDirNonEmptyChildDir, "testDirNonEmptyChildDirF");
   mUfs.mkdirs(testDirEmpty, false);
   mUfs.mkdirs(testDirNonEmpty, false);
   mUfs.mkdirs(testDirNonEmptyChildDir, false);
   createEmptyFile(testDirNonEmptyChildFile);
   createEmptyFile(testDirNonEmptyChildDirFile);
   mUfs.delete(testDirEmpty, false);
   Assert.assertFalse(mUfs.exists(testDirEmpty));
   try {
     mUfs.delete(testDirNonEmpty, false);
   } catch (IOException e) {
     // Some File systems may throw IOException
   }
   Assert.assertTrue(mUfs.exists(testDirNonEmpty));
   mUfs.delete(testDirNonEmpty, true);
   Assert.assertFalse(mUfs.exists(testDirNonEmpty));
   Assert.assertFalse(mUfs.exists(testDirNonEmptyChildDir));
   Assert.assertFalse(mUfs.exists(testDirNonEmptyChildFile));
   Assert.assertFalse(mUfs.exists(testDirNonEmptyChildDirFile));
 }