DeletePOptions deleteOptions = DeletePOptions.newBuilder().setAlluxioOnly(true).build(); mFileSystem.delete(inconsistentUri, deleteOptions); mFileSystem.exists(inconsistentUri); DeletePOptions.newBuilder().setAlluxioOnly(true).setRecursive(true).build(); System.out.println("repairing path: " + uri); mFileSystem.delete(uri, deleteOptions);
@Override protected void runPlainPath(AlluxioURI path, CommandLine cl) throws AlluxioException, IOException { // TODO(calvin): Remove explicit state checking. boolean recursive = cl.hasOption("R"); if (!mFileSystem.exists(path)) { throw new FileDoesNotExistException(ExceptionMessage.PATH_DOES_NOT_EXIST.getMessage(path)); } if (!recursive && mFileSystem.getStatus(path).isFolder()) { throw new IOException( path.getPath() + " is a directory, to remove it, please use \"rm -R <path>\""); } boolean isAlluxioOnly = cl.hasOption(REMOVE_ALLUXIO_ONLY.getLongOpt()); DeletePOptions options = DeletePOptions.newBuilder().setRecursive(recursive).setAlluxioOnly(isAlluxioOnly) .setUnchecked(cl.hasOption(REMOVE_UNCHECKED_OPTION_CHAR)).build(); mFileSystem.delete(path, options); if (!isAlluxioOnly) { System.out.println(path + " has been removed"); } else { System.out.println(path + " has been removed from Alluxio space"); } }
/** * <code>optional .alluxio.grpc.file.FileSystemMasterCommonPOptions commonOptions = 4;</code> */ private com.google.protobuf.SingleFieldBuilderV3< alluxio.grpc.FileSystemMasterCommonPOptions, alluxio.grpc.FileSystemMasterCommonPOptions.Builder, alluxio.grpc.FileSystemMasterCommonPOptionsOrBuilder> getCommonOptionsFieldBuilder() { if (commonOptionsBuilder_ == null) { commonOptionsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< alluxio.grpc.FileSystemMasterCommonPOptions, alluxio.grpc.FileSystemMasterCommonPOptions.Builder, alluxio.grpc.FileSystemMasterCommonPOptionsOrBuilder>( getCommonOptions(), getParentForChildren(), isClean()); commonOptions_ = null; } return commonOptionsBuilder_; } public final Builder setUnknownFields(
boolean recursive = deleteContext.getOptions().getRecursive(); if (inode.isDirectory() && !recursive && mInodeStore.hasChildren(inode.asDirectory())) { if (!deleteContext.getOptions().getAlluxioOnly()) { ufsDeleter = new SafeUfsDeleter(mMountTable, mInodeStore, inodesToDelete, deleteContext.getOptions().build()); mMountTable.delete(rpcContext, alluxioUriToDelete); } else { if (!deleteContext.getOptions().getAlluxioOnly()) { try { checkUfsMode(alluxioUriToDelete, OperationType.WRITE);
DeletePOptions.newBuilder().setRecursive(true).setAlluxioOnly(true).setUnchecked(true));
subBuilder.mergeFrom(options_); options_ = subBuilder.buildPartial();
DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true)));
DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true))); } else { mFileSystemMaster.delete(path, DeleteContext.defaults());
DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true))); fail("Should not have been able to delete the root"); } catch (InvalidPathException e) { .defaults(ListStatusPOptions.newBuilder().setLoadMetadataType(LoadMetadataPType.ALWAYS))); mFileSystemMaster.delete(new AlluxioURI("/mnt/local/dir1/file1"), DeleteContext.defaults(DeletePOptions.newBuilder().setAlluxioOnly(true)));
Metrics.DELETE_PATHS_OPS.inc(); LockingScheme lockingScheme = createLockingScheme(path, context.getOptions().getCommonOptions(), LockPattern.WRITE_EDGE); try (RpcContext rpcContext = createRpcContext(); LockedInodePath inodePath = createAuditContext("delete", path, null, inodePath.getInodeOrNull())) { mPermissionChecker.checkParentPermission(Mode.Bits.WRITE, inodePath); if (context.getOptions().getRecursive()) { try { List<String> failedChildren = new ArrayList<>(); context.getOptions().getRecursive() ? DescendantType.ALL : DescendantType.ONE); if (!inodePath.fullPathExists()) { throw new FileDoesNotExistException(ExceptionMessage.PATH_DOES_NOT_EXIST.getMessage(path));
FileSystem.Factory.get(fsContext); if (fs.exists(testDir)) { fs.delete(testDir, DeletePOptions.newBuilder().setRecursive(true).setUnchecked(true).build());
.defaults(DeletePOptions.newBuilder().setRecursive(true).setAlluxioOnly(true))); } catch (DirectoryNotEmptyException e) { throw new RuntimeException(String.format(
/** * Tests the {@link FileSystemMaster#delete(AlluxioURI, DeleteContext)} method for * a directory. */ @Test public void deleteDir() throws Exception { createFileWithSingleBlock(NESTED_FILE_URI); // delete the dir mFileSystemMaster.delete(NESTED_URI, DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true))); // verify the dir is deleted assertEquals(-1, mFileSystemMaster.getFileId(NESTED_URI)); AlluxioURI ufsMount = new AlluxioURI(mTestFolder.newFolder().getAbsolutePath()); mFileSystemMaster.createDirectory(new AlluxioURI("/mnt/"), CreateDirectoryContext.defaults()); // Create ufs file. Files.createDirectory(Paths.get(ufsMount.join("dir1").getPath())); mFileSystemMaster.mount(new AlluxioURI("/mnt/local"), ufsMount, MountContext.defaults()); // load the dir1 to alluxio mFileSystemMaster.listStatus(new AlluxioURI("/mnt/local"), ListStatusContext .defaults(ListStatusPOptions.newBuilder().setLoadMetadataType(LoadMetadataPType.ALWAYS))); mFileSystemMaster.delete(new AlluxioURI("/mnt/local/dir1"), DeleteContext .defaults(DeletePOptions.newBuilder().setRecursive(true).setAlluxioOnly(true))); // ufs directory still exists assertTrue(Files.exists(Paths.get(ufsMount.join("dir1").getPath()))); // verify the directory is deleted Files.delete(Paths.get(ufsMount.join("dir1").getPath())); assertEquals(IdUtils.INVALID_FILE_ID, mFileSystemMaster.getFileId(new AlluxioURI("/mnt/local/dir1"))); }
/** * {@inheritDoc} * * Moves the file specified in the config to the configured path. If the destination path is a * directory, the file is moved inside that directory. */ @Override public SerializableVoid runTask(MoveConfig config, ArrayList<MoveCommand> commands, JobWorkerContext jobWorkerContext) throws Exception { WriteType writeType = config.getWriteType() == null ? ServerConfiguration.getEnum(PropertyKey.USER_FILE_WRITE_TYPE_DEFAULT, WriteType.class) : WriteType.valueOf(config.getWriteType()); for (MoveCommand command : commands) { move(command, writeType.toProto(), mFileSystem); } // Try to delete the source directory if it is empty. if (!hasFiles(new AlluxioURI(config.getSource()), mFileSystem)) { try { LOG.debug("Deleting {}", config.getSource()); mFileSystem.delete(new AlluxioURI(config.getSource()), DeletePOptions.newBuilder().setRecursive(true).build()); } catch (FileDoesNotExistException e) { // It's already deleted, possibly by another worker. } } return null; }
/** * Attempts to delete the file or directory with the specified path. * * @param path path to delete * @param recursive if true, will attempt to delete all children of the path * @return true if one or more files/directories were deleted; false otherwise */ @Override public boolean delete(Path path, boolean recursive) throws IOException { LOG.debug("delete({}, {})", path, recursive); if (mStatistics != null) { mStatistics.incrementWriteOps(1); } AlluxioURI uri = new AlluxioURI(HadoopUtils.getPathWithoutScheme(path)); DeletePOptions options = DeletePOptions.newBuilder().setRecursive(recursive).build(); try { mFileSystem.delete(uri, options); return true; } catch (InvalidPathException | FileDoesNotExistException e) { LOG.warn("delete failed: {}", e.getMessage()); return false; } catch (AlluxioException e) { throw new IOException(e); } }
@Test public void deleteDirRecursiveWithInsufficientPermissions() throws Exception { // userA has permissions to delete directory but not one of the nested files createFileWithSingleBlock(NESTED_FILE_URI); createFileWithSingleBlock(NESTED_FILE2_URI); mFileSystemMaster.setAttribute(NESTED_URI, SetAttributeContext .defaults(SetAttributePOptions.newBuilder().setMode(new Mode((short) 0777).toProto()))); mFileSystemMaster.setAttribute(NESTED_FILE_URI, SetAttributeContext .defaults(SetAttributePOptions.newBuilder().setMode(new Mode((short) 0700).toProto()))); mFileSystemMaster.setAttribute(NESTED_FILE2_URI, SetAttributeContext .defaults(SetAttributePOptions.newBuilder().setMode(new Mode((short) 0777).toProto()))); try (AuthenticatedClientUserResource userA = new AuthenticatedClientUserResource("userA", ServerConfiguration.global())) { mFileSystemMaster.delete(NESTED_URI, DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true))); fail("Deleting a directory w/ insufficient permission on child should fail"); } catch (AccessControlException e) { String expectedChildMessage = ExceptionMessage.PERMISSION_DENIED .getMessage("user=userA, access=-w-, path=" + NESTED_FILE_URI + ": failed at file"); assertTrue(e.getMessage().startsWith(ExceptionMessage.DELETE_FAILED_DIR_CHILDREN .getMessage(NESTED_URI, expectedChildMessage))); } assertNotEquals(IdUtils.INVALID_FILE_ID, mFileSystemMaster.getFileId(NESTED_URI)); assertNotEquals(IdUtils.INVALID_FILE_ID, mFileSystemMaster.getFileId(NESTED_FILE_URI)); assertNotEquals(IdUtils.INVALID_FILE_ID, mFileSystemMaster.getFileId(NESTED_FILE2_URI)); }
/** * Tests the {@link FileSystemMaster#delete(AlluxioURI, DeleteContext)} method for * a directory with un-synced persistent entries with a sync check. */ @Test public void deleteUnsyncedPersistedDirectoryWithCheck() throws Exception { AlluxioURI ufsMount = createPersistedDirectories(1); mountPersistedDirectories(ufsMount); loadPersistedDirectories(1); // Add a file to the UFS. Files.createFile( Paths.get(ufsMount.join(DIR_TOP_LEVEL).join(FILE_PREFIX + (DIR_WIDTH)).getPath())); // delete top-level directory try { mFileSystemMaster.delete(new AlluxioURI(MOUNT_URI).join(DIR_TOP_LEVEL), DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true) .setAlluxioOnly(false).setUnchecked(false))); fail(); } catch (IOException e) { // Expected } // Check all that could be deleted. List<AlluxioURI> except = new ArrayList<>(); except.add(new AlluxioURI(MOUNT_URI).join(DIR_TOP_LEVEL)); checkPersistedDirectoriesDeleted(1, ufsMount, except); }
/** * <code>optional .alluxio.grpc.file.DeletePOptions options = 2;</code> */ public Builder mergeOptions(alluxio.grpc.DeletePOptions value) { if (optionsBuilder_ == null) { if (((bitField0_ & 0x00000002) == 0x00000002) && options_ != null && options_ != alluxio.grpc.DeletePOptions.getDefaultInstance()) { options_ = alluxio.grpc.DeletePOptions.newBuilder(options_).mergeFrom(value).buildPartial(); } else { options_ = value; } onChanged(); } else { optionsBuilder_.mergeFrom(value); } bitField0_ |= 0x00000002; return this; } /**
/** * Tests the {@link FileSystemMaster#delete(AlluxioURI, DeleteContext)} method for * a multi-level directory with un-synced persistent entries with a sync check. */ @Test public void deleteUnsyncedPersistedMultilevelDirectoryWithCheck() throws Exception { AlluxioURI ufsMount = createPersistedDirectories(3); mountPersistedDirectories(ufsMount); loadPersistedDirectories(3); // Add a file to the UFS down the tree. Files.createFile(Paths.get(ufsMount.join(DIR_TOP_LEVEL).join(DIR_PREFIX + 0) .join(FILE_PREFIX + (DIR_WIDTH)).getPath())); mThrown.expect(IOException.class); // delete top-level directory mFileSystemMaster.delete(new AlluxioURI(MOUNT_URI).join(DIR_TOP_LEVEL), DeleteContext.defaults( DeletePOptions.newBuilder().setRecursive(true).setAlluxioOnly(false).setUnchecked(false))); // Check all that could be deleted. List<AlluxioURI> except = new ArrayList<>(); except.add(new AlluxioURI(MOUNT_URI).join(DIR_TOP_LEVEL)); except.add(new AlluxioURI(MOUNT_URI).join(DIR_TOP_LEVEL).join(DIR_PREFIX + 0)); checkPersistedDirectoriesDeleted(3, ufsMount, except); }
/** * Tests the {@link FileSystemMaster#delete(AlluxioURI, DeleteContext)} method with a * non-empty directory. */ @Test public void deleteNonemptyDirectory() throws Exception { createFileWithSingleBlock(NESTED_FILE_URI); String dirName = mFileSystemMaster.getFileInfo(NESTED_URI, GET_STATUS_CONTEXT).getName(); try { mFileSystemMaster.delete(NESTED_URI, DeleteContext.defaults()); fail("Deleting a non-empty directory without setting recursive should fail"); } catch (DirectoryNotEmptyException e) { String expectedMessage = ExceptionMessage.DELETE_NONEMPTY_DIRECTORY_NONRECURSIVE.getMessage(dirName); assertEquals(expectedMessage, e.getMessage()); } // Now delete with recursive set to true. mFileSystemMaster.delete(NESTED_URI, DeleteContext.defaults(DeletePOptions.newBuilder().setRecursive(true))); }