Java FileSystem.mkdirs方法代码示例

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
/**
 * Creates a savepoint directory.
 *
 * @param baseDirectory Base target directory for the savepoint
 * @param jobId Optional JobID the savepoint belongs to
 * @return The created savepoint directory
 * @throws IOException FileSystem operation failures are forwarded
 */
public static String createSavepointDirectory(@Nonnull String baseDirectory, @Nullable JobID jobId) throws IOException {
	final Path basePath = new Path(baseDirectory);
	final FileSystem fs = basePath.getFileSystem();

	final String prefix;
	if (jobId == null) {
		prefix = "savepoint-";
	} else {
		prefix = String.format("savepoint-%s-", jobId.toString().substring(0, 6));
	}

	Exception latestException = null;

	// Try to create a FS output stream
	for (int attempt = 0; attempt < 10; attempt++) {
		Path path = new Path(basePath, FileUtils.getRandomFilename(prefix));

		try {
			if (fs.mkdirs(path)) {
				return path.toString();
			}
		} catch (Exception e) {
			latestException = e;
		}
	}

	throw new IOException("Failed to create savepoint directory at " + baseDirectory, latestException);
}
 

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
public FileSystemBlobStore(FileSystem fileSystem, String storagePath) throws IOException {
	this.fileSystem = checkNotNull(fileSystem);
	this.basePath = checkNotNull(storagePath) + "/blob";

	LOG.info("Creating highly available BLOB storage directory at {}", basePath);

	fileSystem.mkdirs(new Path(basePath));
	LOG.debug("Created highly available BLOB storage directory at {}", basePath);
}
 

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
public static void copy(Path sourcePath, Path targetPath, boolean executable) throws IOException {
	// TODO rewrite this to make it participate in the closable registry and the lifecycle of a task.
	// we unwrap the file system to get raw streams without safety net
	FileSystem sFS = FileSystem.getUnguardedFileSystem(sourcePath.toUri());
	FileSystem tFS = FileSystem.getUnguardedFileSystem(targetPath.toUri());
	if (!tFS.exists(targetPath)) {
		if (sFS.getFileStatus(sourcePath).isDir()) {
			tFS.mkdirs(targetPath);
			FileStatus[] contents = sFS.listStatus(sourcePath);
			for (FileStatus content : contents) {
				String distPath = content.getPath().toString();
				if (content.isDir()) {
					if (distPath.endsWith("/")) {
						distPath = distPath.substring(0, distPath.length() - 1);
					}
				}
				String localPath = targetPath.toString() + distPath.substring(distPath.lastIndexOf("/"));
				copy(content.getPath(), new Path(localPath), executable);
			}
		} else {
			try (FSDataOutputStream lfsOutput = tFS.create(targetPath, FileSystem.WriteMode.NO_OVERWRITE); FSDataInputStream fsInput = sFS.open(sourcePath)) {
				IOUtils.copyBytes(fsInput, lfsOutput);
				//noinspection ResultOfMethodCallIgnored
				new File(targetPath.toString()).setExecutable(executable);
			} catch (IOException ioe) {
				LOG.error("could not copy file to local file cache.", ioe);
			}
		}
	}
}
 

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
protected Path createBasePath(FileSystem fs, Path checkpointDirectory, JobID jobID) throws IOException {
	Path dir = new Path(checkpointDirectory, jobID.toString());
	fs.mkdirs(dir);
	return dir;
}
 

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
private static void unzipPythonLibrary(Path targetDir) throws IOException {
	FileSystem targetFs = targetDir.getFileSystem();
	ClassLoader classLoader = PythonPlanBinder.class.getClassLoader();
	ZipInputStream zis = new ZipInputStream(classLoader.getResourceAsStream("python-source.zip"));
	ZipEntry entry = zis.getNextEntry();
	while (entry != null) {
		String fileName = entry.getName();
		Path newFile = new Path(targetDir, fileName);
		if (entry.isDirectory()) {
			targetFs.mkdirs(newFile);
		} else {
			try {
				LOG.debug("Unzipping to {}.", newFile);
				FSDataOutputStream fsDataOutputStream = targetFs.create(newFile, FileSystem.WriteMode.NO_OVERWRITE);
				IOUtils.copyBytes(zis, fsDataOutputStream, false);
			} catch (Exception e) {
				zis.closeEntry();
				zis.close();
				throw new IOException("Failed to unzip flink python library.", e);
			}
		}

		zis.closeEntry();
		entry = zis.getNextEntry();
	}
	zis.closeEntry();
}
 

import org.apache.flink.core.fs.FileSystem; //导入方法依赖的package包/类
/**
 * Test that {@link FileUtils#deletePathIfEmpty(FileSystem, Path)} deletes the path if it is
 * empty. A path can only be empty if it is a directory which does not contain any
 * files/directories.
 */
@Test
public void testDeletePathIfEmpty() throws IOException {
	final Path basePath = new Path(hdfsURI);
	final Path directory = new Path(basePath, UUID.randomUUID().toString());
	final Path directoryFile = new Path(directory, UUID.randomUUID().toString());
	final Path singleFile = new Path(basePath, UUID.randomUUID().toString());

	FileSystem fs = basePath.getFileSystem();

	fs.mkdirs(directory);

	byte[] data = "HDFSTest#testDeletePathIfEmpty".getBytes(ConfigConstants.DEFAULT_CHARSET);

	for (Path file: Arrays.asList(singleFile, directoryFile)) {
		org.apache.flink.core.fs.FSDataOutputStream outputStream = fs.create(file, FileSystem.WriteMode.OVERWRITE);
		outputStream.write(data);
		outputStream.close();
	}

	// verify that the files have been created
	assertTrue(fs.exists(singleFile));
	assertTrue(fs.exists(directoryFile));

	// delete the single file
	assertFalse(FileUtils.deletePathIfEmpty(fs, singleFile));
	assertTrue(fs.exists(singleFile));

	// try to delete the non-empty directory
	assertFalse(FileUtils.deletePathIfEmpty(fs, directory));
	assertTrue(fs.exists(directory));

	// delete the file contained in the directory
	assertTrue(fs.delete(directoryFile, false));

	// now the deletion should work
	assertTrue(FileUtils.deletePathIfEmpty(fs, directory));
	assertFalse(fs.exists(directory));
}